二叉树类型的题目是LeeCode中常见的题型

能够结合队列、栈、链表、字符串等多种数据结构；
需要掌握树、图的遍历方式；
需要掌握递归函数的使用，并自己设计具体过程；
实际工程中也会经常遇到。

树的常见遍历有先序遍历、中序遍历、后序遍历三种：

先序遍历：根、左、右
中序遍历：左、根、右
后序遍历：左、右、根

今天我们就介绍下树的基本遍历用Python的递归和迭代的两种实现方式

递归实现

使用递归来实现三种遍历方式是比较容易的，只要改变根结点的打印顺序就可以了

"""
示例二叉树
   1
    
     2
    /
   3
"""
from typing import List


# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    # 先序遍历
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        ret = []

        def pT(node):
            if not node:
                return
            ret.append(node.val)
            pT(node.left)
            pT(node.right)

        pT(root)
        return ret

    # 中序遍历
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        ret = []

        def pT(node):
            if not node:
                return
            pT(node.left)
            ret.append(node.val)
            pT(node.right)

        pT(root)
        return ret

    # 后序遍历
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        ret = []

        def pT(node):
            if not node:
                return
            pT(node.left)
            pT(node.right)
            ret.append(node.val)

        pT(root)
        return ret


if __name__ == "__main__":
    t2 = TreeNode(2)
    t2.left = TreeNode(3)
    t = TreeNode(1)
    t.right = t2

    s = Solution()
    ret = s.preorderTraversal(t)
    print("先序遍历", ret)
    ret = s.inorderTraversal(t)
    print("中序遍历", ret)
    ret = s.postorderTraversal(t)
    print("后序遍历", ret)


执行结果
>> 先序遍历 [1, 2, 3]
>> 中序遍历 [2, 1, 3]
>> 后序遍历 [2, 3, 1]

迭代实现

先序遍历

具体过程：

首先申请一个新的栈，记为stack；
然后将头节点head压入stack中；
每次从stack中弹出栈顶节点，记为cur，然后打印cur节点的值。如果cur右孩子不为空的话，将cur的有孩子先压入stack中；最后如果cur的左孩子不为空的话，将cur的左孩子压入stack中；
不断重复步骤3，直到stack为空，全部过程结束。

from typing import List


# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []

        ret = []
        stack = []
        cur = root
        while stack or cur:
            while cur:
                stack.append(cur)
                ret.append(cur.val)
                cur = cur.left
            cur = stack.pop()
            cur = cur.right
        return ret


if __name__ == "__main__":
	t2 = TreeNode(2)
	t2.left = TreeNode(3)
	t = TreeNode(1)
	t.right = t2
	
	s = Solution()
	ret = s.preorderTraversal(t)
	print(ret)

中序遍历

具体过程：

首先申请一个新的栈，记为stack，申请一个变量cur，cur初始化为头节点；
先把cur节点压入栈中，对以cur节点为头的整棵子树来说，依次把整棵树的左边界压入栈中，即不断令cur=cur.left，然后重复步骤2；
不断重复步骤2，直到发现cur为空，此时从stack中弹出一个节点，记为node；打印node的值，并让cur=node.right，然后继续重复步骤2；
当stack为空并且cur为空时，全部过程结束。

from typing import List


# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        ret = []
        stack = []
        cur = root
        while stack or cur:
            while cur:
                stack.append(cur)
                cur = cur.left
            node = stack.pop()
            ret.append(node.val)
            cur = node.right
        return ret


if __name__ == "__main__":
    t2 = TreeNode(2)
    t2.left = TreeNode(3)
    t = TreeNode(1)
    t.right = t2

    s = Solution()
    ret = s.inorderTraversal(t)
    print(ret)

后序遍历

具体过程：

首先申请两个栈，记为分别s1、s2；
然后将头节点head压入s1中；
从s1中弹出的节点记为cur，然后先把cur的左孩子压入s1中，然后把cur1的右孩子压入s1中；
在整个过程中，每一个从s1中弹出的节点都放进s2中；
不断重复步骤3和步骤4，直到s1为空，过程停止；
从s2中依次弹出节点并打印，打印的顺序就是后序遍历的顺序了。

from typing import List


# Definition for a binary tree node.
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []

        s1 = [root]
        s2 = []
        while s1:
            node = s1.pop()
            s2.append(node.val)
            if node.left:
                s1.append(node.left)
            if node.right:
                s1.append(node.right)
        s2.reverse()
        return s2


if __name__ == "__main__":
    t2 = TreeNode(2)
    t2.left = TreeNode(3)
    t = TreeNode(1)
    t.right = t2

    s = Solution()
    ret = s.preorderTraversal(t)
    print(ret)end

【LeeCode 面试题】二叉树的前序遍历，中序遍历，后序遍历递归和迭代的两种实现方式

二叉树类型的题目是LeeCode中常见的题型

递归实现

迭代实现

先序遍历

中序遍历

后序遍历