跟随carl代码随想录刷题
语言：python

---

🙋递归法与迭代法哪个更好呢？
💁

• 递归法空间复杂度大一些，因为递归需要系统堆栈存参数返回值等等。
• 递归更容易让程序员理解，但收敛不好，容易栈溢出。
• 递归是方便了程序员，难为了机器（各种保存参数，各种进栈出栈）。
• ⭐️在实际项目开发的过程中我们是要尽量避免递归！因为项目代码参数、调用关系都比较复杂，不容易控制递归深度，甚至会栈溢出。——代码随想录

二叉树的递归遍历——深度优先

• 递归的实现就是：每一次递归调用都会把函数的局部变量、参数值和返回地址等压入调用栈中，然后递归返回的时候，从栈顶弹出上一次递归的各项参数。
• 三要素：
  • 确定递归函数的参数和返回值
    • def traversal(root: TreeNode): # 前序遍历
  • 确定终止条件
    • if (root == None) return;如果当前遍历的节点为空就返回
  • 确定单层递归的逻辑
    • result.append(root.val) # 中
    • traversal(root.left) # 左
    • traversal(root.right) # 右
• ⭐️前序遍历、中序遍历、后序遍历代码的唯一区别就是：中、左、右三个子句的顺序区别。

144. 二叉树的前序遍历

题目：给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

完整代码如下

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 1. 初始化一个列表用于后续存放结果
        result = []

        # 2. 定义前序遍历的递归过程
        def traversal(root:TreeNode):
            if root == None:
                return 
            
            result.append(root.val)
            traversal(root.left)
            traversal(root.right)

        # 3. 调用前序遍历的递归函数
        traversal(root)

        # 4. 结果集
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

94. 二叉树的中序遍历

题目：给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

完整代码如下

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 1. 初始化一个列表用于存放结果集
        result = []

        # 2. 中序遍历的函数
        def traversal(root:TreeNode):
            if root == None:
                return
            
            traversal(root.left)
            result.append(root.val)
            traversal(root.right)

        # 3. 调用中序遍历函数
        traversal(root)

        # 4. 返回结果集
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

145. 二叉树的后序遍历

题目：给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。

完整代码如下

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # 1. 初始化一个列表用于存放结果集
        result = []

        # 2. 中序遍历的函数
        def traversal(root:TreeNode):
            if root == None:
                return
            
            traversal(root.left)
            traversal(root.right)
            result.append(root.val)

        # 3. 调用中序遍历函数
        traversal(root)

        # 4. 返回结果集
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

N叉树的递归遍历

589. N 叉树的前序遍历

题目：给定一个 n 叉树的根节点 root ，返回 其节点值的 前序遍历 。

n 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。

题目分析

和二叉树的写法几乎一样，唯一区别：
for ch in root.children: traversal(ch)

完整代码如下

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def preorder(self, root: 'Node') -> List[int]:
        # 1. 初始化一个列表用于后续存放结果
        result = []

        # 2. 定义前序遍历的递归过程
        def traversal(root):
            if root == None:
                return 
            
            result.append(root.val)
            for ch in root.children:
                traversal(ch)
            # traversal(root.right)

        # 3. 调用前序遍历的递归函数
        traversal(root)

        # 4. 结果集
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

590. N 叉树的后序遍历

题目：给定一个 n 叉树的根节点 root ，返回 其节点值的 后序遍历 。

n 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。

输入：root = [1,null,3,2,4,null,5,6]
输出：[5,6,3,2,4,1]

题目分析

• 和二叉树的写法几乎一样，唯一区别：
  for ch in root.children: traversal(ch)
• 只用在上一题N叉树的前序遍历的基础上调换代码位置，即可实现后序遍历。

完整代码如下

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def postorder(self, root: 'Node') -> List[int]:
        # 1. 定义空列表用于存放结果集
        result = []

        # 2. 定义函数
        def traversal(root):
            if root == None:
                return 
            
            for ch in root.children:
                traversal(ch)

            result.append(root.val)

        # 调用函数
        traversal(root)

        # 返回函数
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28