每日一练 — 2022.02.04

原创已于 2022-03-03 20:28:39 修改 · 185 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#深度优先 #算法 #数据结构

于 2022-02-04 19:32:30 首次发布

每日一练 — python 专栏收录该内容

109 篇文章

订阅专栏

本文探讨了三个算法主题：1) 计算二叉树从根到叶节点数字之和，2) 实现二叉树锯齿形层序遍历，以及3) 分割回文串的解决方案。通过实例解析和代码实现，深入理解这些经典问题在信息技术中的应用。

文章目录

一，求根节点到叶节点数字之和
二，二叉树的锯齿形层序遍历
三，分割回文串

一，求根节点到叶节点数字之和

1，程序简介

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。

每条从根节点到叶节点的路径都代表一个数字：

例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。
计算从根节点到叶节点生成的所有数字之和。
叶节点是指没有子节点的节点。

示例 1：

输入：root = [1,2,3]
输出：25
解释：
从根到叶子节点路径
1->2
代表数字
12
从根到叶子节点路径
1->3
代表数字
13
因此，数字总和 = 12 + 13 =
25

示例 2：

输入：root = [4,9,0,5,1]
输出：1026
解释：
从根到叶子节点路径
4->9->5
代表数字 495
从根到叶子节点路径
4->9->1
代表数字 491
从根到叶子节点路径
4->0
代表数字 40
因此，数字总和 = 495 + 491 + 40 =
1026

提示：

树中节点的数目在范围 [1, 1000] 内
0 <= Node.val <= 9
树的深度不超过 10

2，程序代码

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    def sumNumbers(self, root: TreeNode) -> int:
        def dfs(root: TreeNode, sumNumber: int) -> int:
            if not root:
                return 0
            tmpsum = sumNumber * 10 + root.val
            if not root.left and not root.right:
                return tmpsum
            else:
                return dfs(root.left, tmpsum) + dfs(root.right, tmpsum)
        return dfs(root, 0)

二，二叉树的锯齿形层序遍历

1，程序简介

给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如：

给定二叉树 [3,9,20,null,null,15,7],

返回锯齿形层序遍历如下：

[
[3],
[20,9],
[15,7]
]

2，程序代码

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    def zigzagLevelOrder(self, root: TreeNode) -> List[List[int]]:
        import collections
        if not root:
            return []
        res, q = [], collections.deque()
        flag = False
        q.append(root)
        while q:
            temp = []
            flag = not flag
            for _ in range(len(q)):
                node = q.popleft()
                if flag:
                    temp.append(node.val)
                else:
                    temp.insert(0, node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            res.append(temp)
        return res

三，分割回文串

1，程序简介

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文串。返回 s 所有可能的分割方案。

回文串是正着读和反着读都一样的字符串。

示例 1：

输入：s = “aab”
输出：[[“a”,“a”,“b”],[“aa”,“b”]]

示例 2：

输入：s = “a”
输出：[[“a”]]

提示：

1 <= s.length <= 16
s 仅由小写英文字母组成

2，程序代码

class Solution(object):
    def partition(self, s):
        """
        :type s: str
        :rtype: List[List[str]]
        """
        if len(s) == 0:
            return []
        else:
            res = []
            self.dividedAndsel(s, [], res)
        return res
    def dividedAndsel(self, s, tmp, res):
        if len(s) == 0:
            res.append(tmp)
        for i in range(1, len(s) + 1):
            if s[:i] == s[:i][::-1]:
                self.dividedAndsel(s[i:], tmp + [s[:i]], res)