二叉树的遍历

1 # 先序打印二叉树（递归）
2 def preOrderTraverse(node):
3     if node is None:
4         return None
5     print(node.val)
6     preOrderTraverse(node.left)
7     preOrderTraverse(node.right)

 1 # 先序打印二叉树（非递归）
 2 def preOrderTravese(node):
 3     stack = [node]
 4     while len(stack) > 0:
 5         print(node.val)
 6         if node.right is not None:
 7             stack.append(node.right)
 8         if node.left is not None:
 9             stack.append(node.left)
10         node = stack.pop()

1 # 中序打印二叉树（递归）
2 def inOrderTraverse(node):
3     if node is None:
4         return None
5     inOrderTraverse(node.left)
6     print(node.val)
7     inOrderTraverse(node.right)

 1 # 中序打印二叉树（非递归）
 2 def inOrderTraverse(node):
 3     stack = []
 4     pos = node
 5     while pos is not None or len(stack) > 0:
 6         if pos is not None:
 7             stack.append(pos)
 8             pos = pos.left
 9         else:
10             pos = stack.pop()
11             print(pos.val)
12             pos = pos.right

1 # 后序打印二叉树（递归）
2 def postOrderTraverse(node):
3     if node is None:
4         return None
5     postOrderTraverse(node.left)
6     postOrderTraverse(node.right)
7     print(node.val)

 1 # 后序打印二叉树（非递归）
 2 # 使用两个栈结构
 3 # 第一个栈进栈顺序：左节点->右节点->跟节点
 4 # 第一个栈弹出顺序： 跟节点->右节点->左节点(先序遍历栈弹出顺序：跟->左->右)
 5 # 第二个栈存储为第一个栈的每个弹出依次进栈
 6 # 最后第二个栈依次出栈
 7 def postOrderTraverse(node):
 8     stack = [node]
 9     stack2 = []
10     while len(stack) > 0:
11         node = stack.pop()
12         stack2.append(node)
13         if node.left is not None:
14             stack.append(node.left)
15         if node.right is not None:
16             stack.append(node.right)
17     while len(stack2) > 0:
18         print(stack2.pop().val)

# 先进先出选用队列结构
import queue
def layerTraverse(head):
    if not head:
        return None
    que = queue.Queue()      # 创建先进先出队列
    que.put(head)
    while not que.empty():
        head = que.get()    # 弹出第一个元素并打印
        print(head.val)
        if head.left:       # 若该节点存在左子节点,则加入队列（先push左节点）
            que.put(head.left)
        if head.right:      # 若该节点存在右子节点,则加入队列（再push右节点）
            que.put(head.right)