树的非递归遍历：一种很好的算法

  1 # coding:utf-8
  2 
  3 ‘‘‘
  4 递归算法的本质是利用函数的调用栈进行，实际上我们可以自行使用栈来进行模拟，这样的算法空间复杂度为O(h)，h为二叉树的高度。
  5 
  6 前序遍历
  7 首先把根节点入栈，然后在每次循环中执行以下操作：
  8 此时栈顶元素即为当前的根节点，弹出并打印当前的根节点。
  9 把当前根节点的右儿子和左儿子分别入栈（注意是右儿子先入栈左儿子后入栈，这样的话下次出栈的元素才是左儿子，
 10 这样才符合前序遍历的顺序要求：根节点->左儿子->右儿子）。
 11 下面是代码实现。
 12 
 13 
 14 后序遍历
 15 因为后序遍历的顺序是：左子树->右子树->根节点，于是我们在前序遍历的代码中，当访问完当前节点后，先把当
 16 前节点的左子树入栈，再把右子树入栈，这样最终得到的顺序为：根节点->右子树->左子树，刚好是后序遍历倒过
 17 来的版本，于是把这个结果做一次翻转即为真正的后序遍历。而翻转可以通过使用另外一个栈简单完成，这样的代
 18 价是需要两个栈，但就复杂度而言，空间复杂度仍然是O(h)。
 19 
 20 
 21 中序遍历
 22 中序遍历稍微复杂，使用一个指针p指向下一个待访问的节点，p初始化为根节点。在每次循环中执行以下操作：
 23 如果p非空，则把p入栈，p变为p的左儿子。
 24 如果p为空，说明已经向左走到尽头了，弹出当前栈顶元素，进行访问，并把p更新为其右儿子。
 25 ‘‘‘
 26 from random import randint
 27 
 28 class Node(object):
 29     def __init__(self, x):
 30         self.x = x
 31         self.left = None
 32         self.right = None
 33         
 34 def PreOrder(root):
 35     if not root:
 36         return None
 37     
 38     st = [root]    # 辅助栈
 39     path = []      # 遍历路径
 40     while st:
 41         node = st.pop()
 42         path.append(node.x)
 43         if node.right:
 44             st.append(node.right)
 45         if node.left:
 46             st.append(node.left)
 47     return path
 48     
 49 def PostOrder(root):
 50     if not root:
 51         return None
 52     
 53     st = [root]
 54     path = []
 55     while st:
 56         node = st.pop()
 57         path.append(node.x)
 58         if node.left:
 59             st.append(node.left)
 60         if node.right:
 61             st.append(node.right)
 62     return path[::-1] # path值为：根节点->右子树->左子树，所以作一次倒序刚好就是返回结果！
 63         
 64 def InOrder(root):
 65     if not root:
 66         return None
 67     tmp = root; st = []
 68     path = []
 69     while tmp or st:
 70         if tmp:
 71             st.append(tmp)
 72             tmp = tmp.left
 73         else:
 74             tmp = st.pop()
 75             path.append(tmp.x)
 76             tmp = tmp.right
 77             
 78     return path
 79     
 80 def Hierarchy(root):
 81     # write code here
 82     from collections import deque
 83     #if root is None:
 84     #    return None
 85     if not root:
 86         return []
 87 
 88     q = deque()
 89     q.append(root)
 90     ret = []
 91     while len(q) > 0:
 92         node = q.popleft()
 93         ret.append(node.x)
 94         if node.left:
 95             q.append(node.left)
 96         if node.right:
 97             q.append(node.right)
 98         #q.append(node.right) if node.right else pass
 99     return ret  
100         
101 root = Node(1)
102 root.left = Node(2);root.right = Node(3)
103 root.left.left = Node(4); root.left.right = Node(5)
104 root.right.left = Node(6); root.right.right = Node(7)
105 root.left.left.right = Node(8); root.right.left.right = Node(9)
106 print PreOrder(root)
107 print PostOrder(root)
108 print InOrder(root)
109 print Hierarchy(root)

        1
      /       2       3
  /   \   /   4      5  6    7
  \           8        9