leetcode笔记总结——（18）二叉树的前、中、后序遍历（python编写）

力扣地址：
前序遍历.
中序遍历.
后序遍历.

三种遍历的统一写法：

1、思路：

我们以中序遍历为例，因为使用栈的话，无法同时解决访问节点（遍历节点）和处理节点（将元素放进结果集）不一致的情况。

那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

如何标记呢，就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。

2、代码：

详细的思路在注释中。。。。。。

（1）前序遍历：

# 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: TreeNode) -> List[int]:
        res = [] # 用于保存结果
        stack = []
        if root: stack.append(root) # 先把根节点入栈
        while stack:
            node = stack[-1] # 访问栈顶元素
            if node:
                stack.pop() # 弹出当前节点，避免重复操作
                if node.right: stack.append(node.right) # 入栈右节点
                if node.left: stack.append(node.left) # 入栈左节点
                stack.append(node) # 入栈根节点
                stack.append(None) # 由于根节点入栈了，但没处理，因此放入一个空指针作为标记
            else:
                stack.pop() # 出栈空指针
                node = stack.pop() 
                res.append(node.val) 
        
        return res

（2）中序遍历：

你会发现，相比前序遍历，只改变了两行的顺序。

# 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: TreeNode) -> List[int]:
        res = [] # 用于保存结果
        stack = []
        if root: stack.append(root) # 先把根节点入栈
        while stack:
            node = stack[-1] # 访问栈顶元素
            if node:
                stack.pop() # 弹出当前节点，避免重复操作
                if node.right: stack.append(node.right) # 入栈右节点                    右
                stack.append(node) # 入栈根节点                                         中
                stack.append(None) # 由于根节点入栈了，但没处理，因此放入一个空指针作为标记 左
                if node.left: stack.append(node.left) # 入栈左节点
            else:
                stack.pop() # 出栈空指针
                node = stack.pop() 
                res.append(node.val) 
        
        return res

（3）后序遍历：

你会发现，相比前序遍历，只改变了两行的顺序。

# 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: TreeNode) -> List[int]:
        res = [] # 用于保存结果
        stack = []
        if root: stack.append(root) # 先把根节点入栈
        while stack:
            node = stack[-1] # 访问栈顶元素
            if node:
                stack.pop() # 弹出当前节点，避免重复操作
                stack.append(node) # 入栈根节点                                         中
                stack.append(None) # 由于根节点入栈了，但没处理，因此放入一个空指针作为标记  
                if node.right: stack.append(node.right) # 入栈右节点                    右
                if node.left: stack.append(node.left) # 入栈左节点                      左
            else:
                stack.pop() # 出栈空指针
                node = stack.pop() 
                res.append(node.val) 
        
        return res