本文已参与「新人创作礼」活动，一起开启掘金创作之路。 完整版python代码见github.com/lankuohsing… 欢迎给star！

0. 二叉树的定义：

Python版实现：

# In[]
class BinTreeNode:
    def __init__(self, data, left=None, right=None):
        self.data=data
        self.left=left
        self.right=right
        return
class BinTree:
    def __init__(self):
        self.root=None
        return

1. 前序遍历

遍历顺序：父节点->左孩子->右孩子 leetcode 144. 二叉树的前序遍历

1.1. 递归方式前序遍历：

Python版实现：

# 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 recursive(self,node,results):
        if node is None:
            return
        results.append(node.val)
        self.recursive(node.left,results)
        self.recursive(node.right,results)
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        results=[]
        self.recursive(root,results)
        return results

1.2. 非递归方式前序遍历

Python版实现：

# 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]:
        results=[]
        stack_nodes=[]
        while True:
            if root is None:
                if len(stack_nodes)==0:
                    return results
                else:
                    root=stack_nodes.pop()
                    root=root.right
            else:
                results.append(root.val)
                stack_nodes.append(root)
                root=root.left
        return results

2. 中序遍历

遍历顺序：左孩子->父节点->右孩子 leetcode 94. 二叉树的中序遍历

2.1. 递归方式中序遍历：

Python版实现：

# 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 recursive(self, node, results):
        if node is None:
            return
        self.recursive(node.left,results)
        results.append(node.val)
        self.recursive(node.right,results)
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        results=[]
        self.recursive(root,results)
        return results

2.2. 非递归方式中序遍历

Python版实现：

# 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]:
        results=[]
        if root is None:
            return results
        stack_nodes=[]
        while True:
            if root is None:
                if len(stack_nodes)==0:
                    break
                else:
                    root=stack_nodes.pop()
                    results.append(root.val)
                    root=root.right
            else:
                stack_nodes.append(root)
                root=root.left
        return results

3. 后序遍历

遍历顺序：左孩子->右孩子->父节点 leetcode145. 二叉树的后序遍历

3.1. 递归方式后序遍历：

Python版实现：

"""
递归方式后序遍历
"""
# 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 recursive(self,node,results):
        if node is None:
            return
        self.recursive(node.left,results)
        self.recursive(node.right,results)
        results.append(node.val)
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        results=[]
        self.recursive(root,results)
        return results

3.2. 非递归方式后序遍历

Python版实现：

# 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]:
        results=[]
        stack_nodes=[]
        pre_node=None
        while True:
            if root is None:
                if len(stack_nodes)==0:
                    break
                else:
                    root=stack_nodes.pop()
                    if root.right is None or pre_node==root.right:#右孩子为空代表叶结点，pre_node==root.right代表父结点
                        results.append(root.val)
                        pre_node=root
                        root=None
                    else:
                        stack_nodes.append(root)#右孩子不为空，继续将root压栈
                        root=root.right
            else:
                stack_nodes.append(root)
                root=root.left
        return results