代码随想录算法训练营Day 12|Python|递归遍历，迭代遍历

递归遍历 

递归三要素：

1. 确认输入元素和参数
2. 确认递归停止条件
3. 递归逻辑细节

前序遍历：

root->left->right

# 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]:
        value = []
        def dfs(root):
            if not root:
                return []
            value.append(root.val)
            dfs(root.left)
            dfs(root.right)
        dfs(root)
        return value
        

 中序遍历：

left->root->right

# 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]:
        value = []
        def dfs(root):
            if not root:
                return []
            dfs(root.left)
            value.append(root.val)
            dfs(root.right)
        dfs(root)
        return value

后序遍历：

left->right->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]:
        if not root:
            return[]
        left=self.postorderTraversal(root.left)
        right=self.postorderTraversal(root.right)
        return left+right+[root.val]

迭代遍历

前序遍历：

注意现在stack中存入right，然后left。记得更新node=current root

class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        # value = []
        # def dfs(root):
        #     if not root:
        #         return []
        #     value.append(root.val)
        #     dfs(root.left)
        #     dfs(root.right)
        # dfs(root)
        # return value
        stack = [root]
        value = []
        if not root:
            return value
        while stack:
            node = stack.pop()
            value.append(node.val)
            if node.right:
                stack.append(node.right)
            if node.left:
                stack.append(node.left)
            # print(value)
        return value

中序遍历：

解题思路：

输入root，遍历左节点，存入stack，当遇到底部节点时，cur=None，弹出stack的最后一个节点，即底部节点，向上推进，存入中间节点，检查是否有右节点，有的话设置为cur，并推入stack

# 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]:
        if not root:
            return []
        stack = []
        value = []
        cur = root
        while cur or stack:
            if cur:
                stack.append(cur)
                cur = cur.left#到达左底端，最后一层cur=None
            else:
                cur = stack.pop()#如果cur=None，继续向上层推进
                value.append(cur.val)
                cur = cur.right
        return value

后序遍历：

类似前序遍历。先将left加入stack，再将right加入，将value list reverse输出即可。

# 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]:
        if not root:
            return []
        value = []
        stack = [root]
        while stack:
            node = stack.pop()
            value.append(node.val)
            if node.left:
                stack.append(node.left)
            if node.right:
                stack.append(node.right)
        return value[::-1]