给定一个二叉树
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
进阶：
- 你只能使用常量级额外空间。
- 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
示例：
输入：root = [1,2,3,4,5,null,7]
输出：[1,#,2,3,#,4,5,7,#] 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。
提示：
- 树中的节点数小于
6000 -100 <= node.val <= 100
1 """ 2 # Definition for a Node. 3 class Node: 4 def __init__(self, val, left, right, next): 5 self.val = val 6 self.left = left 7 self.right = right 8 self.next = next 9 """ 10 class Solution: 11 def connect(self, root: 'Node') -> 'Node': 12 if root is None: 13 return None 14 if root.left: 15 if root.right: 16 root.left.next = root.right 17 else: 18 root.left.next = self.__nextLeftNode(root.next) 19 if root.right: 20 root.right.next = self.__nextLeftNode(root.next) 21 self.connect(root.right) 22 self.connect(root.left) 23 return root 24 25 def __nextLeftNode(self, root: 'Node') -> 'Node': 26 while root: 27 if root.left: 28 return root.left 29 elif root.right: 30 return root.right 31 else: 32 root = root.next 33 return None
129. 求根到叶子节点数字之和
难度中等
给定一个二叉树，它的每个结点都存放一个 0-9 的数字，每条从根到叶子节点的路径都代表一个数字。
例如，从根到叶子节点路径 1->2->3 代表数字 123。
计算从根到叶子节点生成的所有数字之和。
说明: 叶子节点是指没有子节点的节点。
示例 1:
输入: [1,2,3]
1
/
2 3
输出: 25
解释:
从根到叶子节点路径 1->2 代表数字 12.
从根到叶子节点路径 1->3 代表数字 13.
因此，数字总和 = 12 + 13 = 25.
示例 2:
输入: [4,9,0,5,1]
4
/
9 0
/
5 1
输出: 1026
解释:
从根到叶子节点路径 4->9->5 代表数字 495.
从根到叶子节点路径 4->9->1 代表数字 491.
从根到叶子节点路径 4->0 代表数字 40.
因此，数字总和 = 495 + 491 + 40 = 1026.
1 # Definition for a binary tree node. 2 # class TreeNode: 3 # def __init__(self, x): 4 # self.val = x 5 # self.left = None 6 # self.right = None 7 8 class Solution: 9 def sumNumbers(self, root: TreeNode) -> int: 10 res = list() 11 self.__getNumbers(root, list(), res) 12 Sum = self.__computeNumbersSum(res) 13 return Sum 14 15 def __getNumbers(self, root: TreeNode, path, res) -> None: 16 if not root: 17 return 18 path = path + [root.val] 19 if not root.left and not root.right: 20 res.append(path) 21 return 22 self.__getNumbers(root.left, path, res) 23 self.__getNumbers(root.right, path, res) 24 25 def __computeNumbersSum(self, numbers): 26 Sum = 0 27 for eachElement in numbers: 28 Sum = Sum + int( "".join([str(i) for i in eachElement])) 29 return Sum
130. 被围绕的区域
难度中等
给定一个二维的矩阵，包含 'X' 和 'O'（字母 O）。
找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。
示例:
X X X X X O O X X X O X X O X X
运行你的函数后，矩阵变为：
X X X X X X X X X X X X X O X X
解释:
被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O' 最终都会被填充为 'X'。
如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
1 class Solution: 2 def solve(self, board: List[List[str]]) -> None: 3 """ 4 Do not return anything, modify board in-place instead. 5 """ 6 if not board: 7 return 8 row_num = len(board) 9 column_num = len(board[0]) 10 11 self.__dfs(row_num, column_num, board) 12 self.__replace(row_num, column_num, board) 13 14 def __dfs(self, row_num: int, column_num: int, board: List[List[str]])->None: 15 if not board: 16 return 17 for index in range(row_num): 18 self.__dfsPre(index, 0, row_num, column_num, board) 19 self.__dfsPre(index, column_num-1, row_num, column_num, board) 20 for index in range(column_num): 21 self.__dfsPre(0, index, row_num, column_num, board) 22 self.__dfsPre(row_num-1, index, row_num, column_num, board) 23 24 def __dfsPre(self, i_index: int, j_index: int, row_num: int, column_num: int, board: List[List[str]])->None: 25 26 if i_index < 0 or i_index >= row_num 27 or j_index < 0 or j_index >= column_num 28 or board[i_index][j_index] != 'O': 29 return 30 board[i_index][j_index] = 'B' 31 self.__dfsPre(i_index-1, j_index, row_num, column_num, board) 32 self.__dfsPre(i_index+1, j_index, row_num, column_num, board) 33 self.__dfsPre(i_index, j_index-1, row_num, column_num, board) 34 self.__dfsPre(i_index, j_index+1, row_num, column_num, board) 35 36 def __replace(self, row_num: int, column_num: int, board: List[List[str]])->None: 37 for i_index in range(row_num): 38 for j_index in range(column_num): 39 if board[i_index][j_index] == 'O': 40 board[i_index][j_index] = 'X' 41 if board[i_index][j_index] == 'B': 42 board[i_index][j_index] = 'O'
199. 二叉树的右视图
难度中等
给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例:
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:
1 <---
/
2 3 <---
5 4 <---
1 # Definition for a binary tree node. 2 # class TreeNode: 3 # def __init__(self, x): 4 # self.val = x 5 # self.left = None 6 # self.right = None 7 8 class Solution: 9 def rightSideView(self, root: TreeNode) -> List[int]: 10 if not root: 11 return [] 12 if not root.left and not root.right: 13 return [root.val] 14 15 RRes = self.rightSideView(root.right) 16 LRes = self.rightSideView(root.left) 17 if not LRes and RRes: 18 return [root.val] + RRes 19 elif LRes and not RRes: 20 return [root.val] + LRes 21 else: 22 temp = [LRes[i] for i in range(len(RRes), len(LRes)) ] 23 return [root.val] + RRes + temp
200. 岛屿数量
难度中等
给定一个由 '1'（陆地）和 '0'（水）组成的的二维网格，计算岛屿的数量。一个岛被水包围，并且它是通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设网格的四个边均被水包围。
示例 1:
输入: 11110 11010 11000 00000 输出: 1
示例 2:
输入: 11000 11000 00100 00011 输出: 3
1 class Solution: 2 def numIslands(self, grid: List[List[str]]) -> int: 3 if not grid: 4 return 0 5 Num = 0 6 row_num = len(grid) 7 column_num = len(grid[0]) 8 9 for i_index in range(row_num): 10 for j_index in range(column_num): 11 if grid[i_index][j_index] == "1": 12 self.__dfs(i_index, j_index, row_num, column_num, grid) 13 Num = Num + 1 14 15 return Num 16 17 18 def __dfs(self, i_index: int, j_index: int, row_num: int, column_num: int, board: List[List[str]])->None: 19 20 if i_index < 0 or i_index >= row_num 21 or j_index < 0 or j_index >= column_num 22 or board[i_index][j_index] != "1": 23 return 24 board[i_index][j_index] = "2" 25 self.__dfs(i_index-1, j_index, row_num, column_num, board) 26 self.__dfs(i_index+1, j_index, row_num, column_num, board) 27 self.__dfs(i_index, j_index-1, row_num, column_num, board) 28 self.__dfs(i_index, j_index+1, row_num, column_num, board) 29
257. 二叉树的所有路径
难度简单
给定一个二叉树，返回所有从根节点到叶子节点的路径。
说明: 叶子节点是指没有子节点的节点。
示例:
输入: 1 / 2 3 5 输出: ["1->2->5", "1->3"] 解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3
1 # Definition for a binary tree node. 2 # class TreeNode: 3 # def __init__(self, x): 4 # self.val = x 5 # self.left = None 6 # self.right = None 7 8 class Solution: 9 def binaryTreePaths(self, root: TreeNode) -> List[str]: 10 if not root: 11 return [] 12 res = list() 13 self.binaryTreePathsPre(root, '', res) 14 return res 15 16 17 def binaryTreePathsPre(self, root: TreeNode, path: str, res_temp: list) -> None: 18 if not root: 19 return 20 if not root.left and not root.right: 21 res_temp.append(path + str(root.val)) 22 return 23 self.binaryTreePathsPre(root.left, path + str(root.val) +'->', res_temp) 24 self.binaryTreePathsPre(root.right, path + str(root.val) +'->', res_temp)
337. 打家劫舍 III
难度中等
在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。
示例 1:
输入: [3,2,3,null,3,null,1]
3
/
2 3
3 1
输出: 7
解释: 小偷一晚能够盗取的最高金额 = 3 + 3 + 1 = 7.
示例 2:
输入: [3,4,5,1,3,null,1]
3
/
4 5
/
1 3 1
输出: 9
解释: 小偷一晚能够盗取的最高金额 = 4 + 5 = 9.
1 # Definition for a binary tree node. 2 # class TreeNode: 3 # def __init__(self, x): 4 # self.val = x 5 # self.left = None 6 # self.right = None 7 8 class Solution: 9 def rob(self, root: TreeNode) -> int: 10 return max(self.__dfs(root)) 11 12 def __dfs(self, root: TreeNode)->(int,int): 13 if not root: 14 return 0, 0 15 if not root.left and not root.right: 16 return root.val, 0 17 18 leftSelected, leftNotSelected = self.__dfs(root.left) 19 rightSelected, rightNotSelected = self.__dfs(root.right) 20 21 rootSelected = root.val + leftNotSelected + rightNotSelected 22 rootNotSelected = max(leftSelected, leftNotSelected) + max(rightSelected, rightNotSelected) 23 return rootSelected, rootNotSelected