关于二叉树的各种遍历及变形总结(python实现篇)

二叉树的基本遍历方式分为前序遍历， 中序遍历， 后序遍历，层序遍历。这里主要对四种遍历方式的非递归实现进行总结。

• 前序遍历：使用辅助栈存储节点，首先指针指向根节点，若栈不为空或者指针不为空，循环执行以下操作：
  
  1. 访问指针节点，并将指针节点入栈。
  2. 若指针节点不为空，则访问指针节点，同时将左孩子入栈，更新指针节点指向左孩子。循环步骤2，直到当前指针节点为空。
  3. 若指针节点为空，取栈顶节点出栈，更新指针节点指向栈顶元素的右孩子(注意：这里不将右孩子入栈，是因为下一次循环中会将该指针节点入栈)。

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None


class Solution:
    def PreOrder(self, root):
        if not root:
            return
        print root.val,
        self.PreOrder(root.left)
        self.PreOrder(root.right)

    # 前序遍历非递归实现，向左访问到底，取栈顶元素，右节点入栈
    def PreOrder_iter1(self, root):
        nodestack = []
        while len(nodestack) > 0 or root:
            while root:
                print root.val,
                nodestack.append(root)
                root = root.left
            if len(nodestack) > 0:
                root = nodestack[-1]
                del nodestack[-1]
                root = root.right

    # 前序遍历的一种特殊实现，根节点入栈，只要栈不为空，出栈顶元素访问，并依次将其右节点，左节点入栈
    def PreOrder_iter2(self, root):
        nodestack = []
        if root:
            nodestack.append(root)
            while len(nodestack) > 0:
                root = nodestack[-1]
                del nodestack[-1]
                print root.val,
                if root.right:
                    nodestack.append(root.right)
                if root.left:
                    nodestack.append(root.left)

• 中序遍历：使用辅助栈存储节点，首先指针指向根节点，若栈不为空或者指针不为空，循环执行以下操作：
  
  1. 若指针节点不为空，将指针节点入栈，更新指针节点指向左孩子。循环步骤2，直到当前指针节点为空。
  2. 若指针节点为空，取栈顶节点出栈，访问栈顶节点。更新指针节点指向右孩子。

    def InOder(self, root):
        if not root:
            return
        self.InOder(root.left)
        print root.val,
        self.InOder(root.right)

    def InOrder_iter(self, root):
        nodestack = []
        while len(nodestack) > 0 or root:
            while root:
                nodestack.append(root)
                root = root.left
            if len(nodestack) > 0:
                root = nodestack[-1]
                del nodestack[-1]
                print root.val,
                root = root.right

• 后序遍历：后序遍历是三种遍历中最复杂的，当节点无左孩子时，不能简单的将栈顶元素出栈访问，而是要判断该节点右子树是否已经访问。通常可以修改树结构，增加visited标志位表示其右孩子是否已经被访问。这里采用另一种方式不修改原树结构，而是记录访问的前一节点prenode。首先prenode和节点指针指向根节点，若栈不为空或者指针不为空，循环执行以下操作：
  
  1. 将指针节点入栈
  2. 若指针节点不为空，将指针节点入栈，更新指针节点指向左孩子。循环步骤2，直到当前指针节点为空。
  3. 若指针节点左孩子为空，取栈顶节点出栈。如果栈顶节点的右孩子为空，或者右孩子是上一个访问的节点，访问栈顶节点。prenode更新为栈顶节点，更新指针节点为空。否则指针指向栈顶节点的右孩子。（这里比较难以理解的是更新指针节点为空。如果当前节点被访问，那么表示以该节点为根节点的子树已经全部被访问过，那么下一次被访问的一定是当前节点的根节点，也即是栈中下一个元素。将指针节点置空可以保证下一次循环中不会再将已访问的节点的左子树入栈）

    def PostOrder(self, root):
        if not root:
            return
        self.PostOrder(root.left)
        self.PostOrder(root.right)
        print root.val,

    def PostOrder_iter(self, root):
        nodestack = []
        prenode = root
        while len(nodestack) > 0 or root:
            # 左孩子走到底
            while root:
                nodestack.append(root)
                root = root.left
            if len(nodestack) > 0:
                root = nodestack[-1]
                # 如果右孩子为空，或者右孩子是上一个访问的节点
                if not root.right or root.right == prenode:
                    del nodestack[-1]
                    print root.val,
                    prenode = root
                    root = None
                else:
                    root = root.right

• 层序遍历：使用辅助队列存储节点，首先将根节点入队列。若栈不为空或者指针不为空，循环执行以下操作：
  
  1. 若队列不为空，节点出队列，依次将该节点的左孩子、右孩子入队列，并访问节点

def LevelOrder(self, root):
        nodelist = []
        nodelist.append(root)
        while len(nodelist) != 0:
            root = nodelist[0]
            del nodelist[0]
            if root is not None:
                print root.val
                nodelist.append(root.left)
                nodelist.append(root.right)

测试代码：

t1 = TreeNode(1)
t2 = TreeNode(2)
t3 = TreeNode(3)
t4 = TreeNode(4)
t5 = TreeNode(5)
t6 = TreeNode(6)
t7 = TreeNode(7)
t4.left = t2
t4.right = t6
t3.left = t1
t2.right = t3
t6.left = t5
t6.right = t7
solu = Solution()
print "前序遍历（递归）："
solu.PreOrder(t4)
print "\n前序遍历（非递归）："
solu.PreOrder_iter1(t4)
print "\n前序遍历（非递归）第二种方法："
solu.PreOrder_iter2(t4)
print "\n中序遍历（递归）："
solu.InOder(t4)
print "\n中序遍历（非递归）："
solu.InOrder_iter(t4)
print "\n后序遍历（递归）："
solu.PostOrder(t4)
print "\n后序遍历（非递归）："
solu.PostOrder_iter(t4)
print "\n层序遍历："
solu.LevelOrder(t4)

测试二叉树结构如下：

执行结果

前序遍历（递归）：
4 2 3 1 6 5 7 
前序遍历（非递归）：
4 2 3 1 6 5 7 
前序遍历（非递归）第二种方法：
4 2 3 1 6 5 7 
中序遍历（递归）：
2 1 3 4 5 6 7 
中序遍历（非递归）：
2 1 3 4 5 6 7 
后序遍历（递归）：
1 3 2 5 7 6 4 
后序遍历（非递归）：
1 3 2 5 7 6 4
层序遍历：
4 2 6 3 5 7 1 

除了这四种基本遍历方式外，还有多种基于遍历的变形题目

• 层序遍历，按照每层分组输出结果
• 按之字形遍历