算法漫游指北（第十四篇）:二叉树的深度优先遍历、前序遍历（递归方式/非递归方式）、中序遍历（递归方式/非递归方式）、后序遍历（递归方式/非递归方式）

时间：2020-07-04 01:10:49 阅读：70 评论：0 收藏：0 [点我收藏+]

标签：详细中序 def 建二叉树 while sel 遍历 pytho 左右子树

一、二叉树的深度优先遍历

对于一颗二叉树，深度优先搜索(Depth First Search)是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。那么深度遍历有重要的三种方法。这三种方式常被用于访问树的节点，它们之间的不同在于访问每个节点的次序不同。这三种遍历分别叫做先序遍历（preorder_traversal），中序遍历（inorder_traversal）和后序遍历（postorder_traversal）。我们来给出它们的详细定义，然后举例看看它们的应用。

递归实现先序、中序、后序非常强大的地方是每个都会访问同一个节点三次，所以三个遍历方式只是调换一下函数执行顺序。

无论是否是递归方式都用到了栈(函数栈也是栈)：因为树的结构是从上到下访问，如果要返回去访问另一处的节点，那么必须要有栈来“记忆”。

前序遍历

在先序遍历中，我们先访问根节点，然后递归使用先序遍历访问左子树，再递归使用先序遍历访问右子树根节点->左子树->右子树 Python代码实现：

递归方式前序遍历

    def pre_order_traversal(self, node):
        """递归实现前序遍历"""
        if node == None:
            return
        print(node.elem,end=‘ ‘)
        self.pre_order_traversal(node.lchild)
        self.pre_order_traversal(node.rchild)
?

思路：

1、先打印根节点

2、再执行self.pre_order_traversal(node.lchild)递归的寻找到二叉树的左节点，

此时左边的节点也作为一个树的根节点，打印，

直到找到树的左边的叶节点，

打印左边的叶节点，打印这个叶节点的所在树的右边的叶节点。

3、返回上一层树，已经处理完上一层树左边的子树，开始处理上一层树的右子树

也是先打印这个右子树的根节点，如果这个子树层次多，需要递归则重复第二步

4、处理完右子树继续返回上一层树，递归的处理完整个二叉树的左子树，开始处理右子树。

重复执行第二步，直到递归到最右的叶节点，叶节点的lchild或者rchild为None，则结束递归。

非递归方式前序遍历

   def pre_order_traversal_not_recursion(self,node):
        """前序遍历，非递归方式"""
        if node == None:
            return
        ret = []
        stack = []
        while node or stack:
            while node:
                ret.append(node.elem)
                stack.append(node)
                node = node.lchild
            if stack:
                t = stack.pop()
                node = t.rchild
        return ret
?

思路：

使用列表保存结果；
使用栈（列表实现）存储节点；
当根节点存在，保存结果，根节点入栈；
将根节点指向左子树；
根节点不存在，栈顶元素出栈，并将根节点指向栈顶元素的右子树；
重复步骤3-6，直到栈空。

中序遍历

在中序遍历中，我们递归使用中序遍历访问左子树，然后访问根节点，最后再递归使用中序遍历访问右子树左子树->根节点->右子树 Python代码实现：

递归方式中序遍历

    def in_order_traversal(self, node):
        """递归中序遍历"""
        if node is None:
            return
        self.in_order_traversal(node.lchild)
        print(node.elem, end=" ")
        self.in_order_traversal(node.rchild)

思路：

1、先递归的执行寻找左节点，直到找到左子树的左边的叶节点，打印，

2、然后找到该层子树的根节点，右节点，返回上一层

3、已经处理完该层的左子树，打印该层的根节点，然后处理右子树，重复第二步

4、当整个二叉树做子树已经处理完后，打印根节点，处理右子树，重复第二步。

5、当处理到右子树最右的叶节点时，递归结束。

非递归方式中序遍历

    def in_order_traversal_not_recursion(self,node):
        """非递归方式的中序遍历"""
        if node == None:
            return
        ret = []
        stack = []
        while node or stack:
            while node:
                stack.append(node)
                node = node.lchild
            if stack:
                t = stack.pop()
                ret.append(t.elem)
                node = t.rchild
        return ret

思路：

使用一个栈保存节点（列表实现）；
如果节点存在，入栈，然后将当前指针指向左子树，直到为空；
当前节点不存在，则出栈栈顶元素，取得当前节点的值，并把当前指针指向栈顶元素的右子树；
栈不为空，循环2、3步。

后序遍历

在后序遍历中，我们先递归使用后序遍历访问左子树和右子树，最后访问根节点左子树->右子树->根节点 Python代码实现：

递归方式后序遍历

    def post_order_traversal(self, node):
        
        """递归的后序遍历"""
        if node is None:
            return
        self.post_order_traversal(node.lchild)
        self.post_order_traversal(node.rchild)
        print(node.elem, end=" ")

思路：

1、先递归的寻找左节点，直到左子树的最左边的叶节点，打印这个节点的值

2、返回上一层，递归的该子树找到右节点打印，返回上一层

3、重复执行第二步，直到处理完整个二叉树的左子树，开始处理右子树，重复第二步

4、直到整个二叉树的左右子树都处理完了，打印根节点的值，递归结束。

非递归方式后序遍历

    def post_order_traversal_not_recursion(self, node):
        """非递归方式的后序遍历"""
        if node == None:
            return
        ret = []
        stack = []
        while node or stack:
            while node:
                ret.append(node.elem)
                stack.append(node)
                node = node.rchild
            if stack:
                top = stack.pop()
                node = top.lchild
        return ret[::-1]

思路：