二叉树的遍历-- 使用顺序存储（也就是用列表）和链式存储（对象）

参考《数据结构(python+Java)微课版》，蒋理 著

二叉树（Binary Tree）是指树中节点的度不大于2的有序树（左子树先于右子树）

二叉树的遍历（Traversal）是指沿着某条搜索路线，依次对树中的每个节点做一次且仅做一次的访问。

分为先序遍历，中序遍历，后序遍历

例如，二叉树如下

1. 顺序存储 （也就是用列表存储这个二叉树，第一个总是None, 第二个开始根节点，所以遍历是也从根节点开始）

# 用顺序表实现二叉树遍历
class BinaryListTree(object):
    def __init__(self):
        self.tree = [None, "A", "B", "C", "D", None, "E", "F"]

    # 先序遍历
    def preOrder(self, i: int, tree: list):
        if i >= len(tree):
            return
        if tree[i] is None:
            return
        print(self.tree[i], end="  ")
        self.preOrder(2*i, tree)
        self.preOrder(2*i + 1, tree)


    # 中序遍历
    def midOrder(self, i: int, tree: []):
        if i >= len(tree):
            return
        if tree[i] is None:
            return
        self.midOrder(2 * i, tree)
        print(self.tree[i], end="  ")
        self.midOrder(2 * i + 1, tree)

    # 后序遍历
    def postOrder(self, i: int, tree: []):
        if i >= len(tree):
            return
        if tree[i] is None:
            return
        self.postOrder(2 * i, tree)
        self.postOrder(2 * i + 1, tree)
        print(self.tree[i], end="  ")

if __name__ == "__main__":
    t = BinaryListTree()
    print("先序遍历--", end = " ")
    t.preOrder(1, t.tree)
    print()
    print("中序遍历--", end=" ")
    t.midOrder(1, t.tree)
    print()
    print("后序遍历--", end=" ")
    t.postOrder(1, t.tree)
    print()

结果为

先序遍历-- A  B  D  C  E  F  
中序遍历-- D  B  A  E  C  F  
后序遍历-- D  B  E  F  C  A  

2. 链式存储

class Node(object):
    def __init__(self, data):
        self.data = data
        self.lchild: Node = None
        self.rchild: Node = None

class BinaryTree_Node_Traversal(object):
    def __init__(self):
        self.root: Node = self.initTree()

    def initTree(self):
        n1 = Node("A")
        n2 = Node("B")
        n3 = Node("C")
        n4 = Node("D")
        n6 = Node("E")
        n7 = Node("F")
        n1.lchild = n2
        n1.rchild = n3
        n2.lchild = n4
        n3.lchild = n6
        n3.rchild = n7
        return n1

    # 先序遍历
    def preOrder(self, node:Node):
        if node is None:
            return
        print(node.data, end="  ")
        self.preOrder(node.lchild)
        self.preOrder(node.rchild)

    # 中序遍历
    def midOrder(self, node:Node):
        if node is None:
            return
        self.midOrder(node.lchild)
        print(node.data, end="  ")
        self.midOrder(node.rchild)

    # 后序遍历
    def postOrder(self, node:Node):
        if node is None:
            return
        self.postOrder(node.lchild)
        self.postOrder(node.rchild)
        print(node.data, end="  ")

if __name__ == "__main__":
    t = BinaryTree_Node_Traversal()
    print("先序遍历--", end = " ")
    t.preOrder(t.root)
    print()
    print("中序遍历--", end=" ")
    t.midOrder(t.root)
    print()
    print("后序遍历--", end=" ")
    t.postOrder(t.root)
    print()

结果为

先序遍历-- A  B  D  C  E  F  
中序遍历-- D  B  A  E  C  F  
后序遍历-- D  B  E  F  C  A