前序遍歷結果：1, 2, 4, 5, 8, 9, 11, 3, 6, 7, 10
中序遍歷結果：4, 2, 8, 5, 11, 9, 1, 6, 3, 10, 7
後序遍歷結果：4, 8, 11, 9, 5, 2, 6, 10, 7, 3, 1

根節點表示：

class Node(object):
    def __init__(self, value=None, left=None, right=None):
        self.value = value
        self.left = left
        self.right = right

if __name__ == "__main__":
    tree = Node
 
(1, Node(2, Node(4), Node(5, Node(8), Node(9, left=Node(11)))), Node(3, Node(6), Node(7, left=Node(10))))

1、深度優先遍歷

1.1 遞迴

# 前序遍歷（遞迴）
def pre_deep_func(root):
    if root is None:
        return
    print(root.value)  # print 放到下一行 就是中序遍歷，放到最後 就是後序遍歷
    pre_deep_func(root.left)
    pre_deep_func(root.right)
 

1.2 非遞迴

# 前序遍歷（根左右）:模擬壓棧過程
# 入棧之前讀（根、左），這樣出棧時再讀右（也是右結點子節點們的根）
def pre_deep_func2(root):
    a = []
    while a or root:
        while root:
            print root.value
            a.append(root)
            root = root.left
        h = a.pop()
        root = h.right
# 中序遍歷（左根右）:模擬壓棧過程
# 出棧之後讀（左、根），這樣出棧後指標變更再讀右
 

def mid_deep_func2(root):
    a = []
    while a or root:
        while root:
            a.append(root)
            root = root.left
        h = a.pop()
        print h.value
        root = h.right
# 後序遍歷（左右根）:模擬逆序(根右左)存入陣列b，然後再陣列b逆序輸出
# (根右左)與(根左右)類似，入棧a前讀（根、右），出棧後指標變更再讀左
def after_deep_func2(root):
    a = []
    b = []
    while a or root:
        while root:
            b.append(root.value)
            a.append(root)
            root = root.right
        h = a.pop()
        root = h.left
    print b[::-1]

2、廣度優先遍歷

def level_func(root):
    a = []
    a.append(root)
    while a:
        head = a.pop(0)
        print head.value
        if head.left:
            a.append(head.left)
        if head.right:
            a.append(head.right)

3、求深度
3.1 利用廣度優先遍歷

def get_level_func1(root):
    a = []
    b = []
    a.append(root)
    b.append(1)
    while a:
        head = a.pop(0)
        p = b.pop(0)
        if head.left:
            a.append(head.left)
            b.append(p+1)
        if head.right:
            b.append(p+1)
            a.append(head.right)
    return p

3.2 遞迴方法

def get_level_func2(root):
    if not root:
        return 0
    left = right = 0
    left = get_level_func2(root.left)
    right = get_level_func2(root.right)
    return max(left, right) + 1

4、已知二叉樹前序中序，還原二叉樹

def get_tree(pre, mid):
    if len(pre) == 0:
        return None
    if len(pre) == 1:
        return Node(pre[0])
    root = Node(pre[0])
    root_index = mid.index(pre[0])
    root.left = get_tree(pre[1:root_index + 1], mid[:root_index])
    root.right = get_tree(pre[root_index + 1:], mid[root_index + 1:])
    return root

# head = get_tree([1, 2, 4, 5, 8, 9, 11, 3, 6, 7, 10], [4, 2, 8, 5, 11, 9, 1, 6, 3, 10, 7])
# pre_deep_func(head)

5、已知前序和中序，求後序

def get_after_deep(pre, mid, a):
    if len(pre) == 1:
        a.append(pre[0])
        return
    if len(pre) == 0:
        return
    root = pre[0]
    root_index = mid.index(root)
    get_after_deep(pre[1:root_index+1], mid[:root_index], a)
    get_after_deep(pre[root_index+1:], mid[root_index+1:], a)
    a.append(root)
    return a

# res = get_after_deep([1, 2, 4, 5, 8, 9, 11, 3, 6, 7, 10], [4, 2, 8, 5, 11, 9, 1, 6, 3, 10, 7], [])
# res = [4, 8, 11, 9, 5, 2, 6, 10, 7, 3, 1]