python实现二叉树的广度优先遍历和深度优先遍历

定义

二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。

性质

性质1: 在二叉树的第i层上至多有2^(i-1)个节点（i>0）
性质2: 深度为k的二叉树至多有2^k - 1个节点（k>0）
性质3: 对于任意一棵二叉树，如果其叶节点数为N0，而度数为2的节点总数为N2，则N0=N2+1;
性质4: 具有n个节点的完全二叉树的深度必为 log2(n+1)
性质5: 对完全二叉树，若从上至下、从左至右编号，则编号为i的节点，其左子节点编号必为2i，其右子节点编号必为2i＋1；其父节点的编号必为i//2（i＝1 时为根,除外）

二叉树的分类

    完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶节点，并且叶节点都是从左到右依次排布，这就是完全二叉树。

满二叉树——除了叶节点外每一个节点都有左右子节点且所有叶节点都处在最底层的二叉树。

二叉树的遍历

    广度优先遍历breadth first traversal：又称层次遍历，从树的根节点(root)开始，从上到下从从左到右遍历整个树的节点。
    深度优先遍历depth first traversal：对于一颗二叉树，深度优先遍历是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。深度优先遍历有重要的三种方法。这三种方式常被用于访问树的节点，它们之间的不同在于访问每个节点的次序不同。这三种遍历分别叫做先序遍历（preorder）：根节点->左子树->右子树，中序遍历（inorder）：左子树->根节点->右子树，和后序遍历（postorder）：左子树->右子树->根节点。这三种都是递归方式实现对一整个二叉树遍历的哦。

代码实现

先定义一个Node类，用于实现树上的节点。每个节点有三个属性：节点存放的元素item，左子树lchild，右子树rchild：

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

然后就可以写二叉树的类了：

class Tree():
    # 先定义一个带默认值None的根节点
    def __init__(self, root = None):
        self.root = root
    # 定义添加元素的方法
    def add(self, item):
        node = Node(item)
        if self.root == None:
            self.root = node
        else:
            # 注意这里是用队列的方式来循环判断当前节点有没有可加入位置的
            queue = []
            queue.append(self.root)
            while queue:
                cur = queue.pop(0)
                if cur.lchild == None:
                    cur.lchild = node
                    return
                elif cur.rchild == None:
                    cur.rchild = node
                    return
                else:
                    queue.append(cur.lchild)
                    queue.append(cur.rchild)
    # 定义广度优先遍历(层次遍历)方法
    def breadth_travel(self):
        if self.root == None:
            return
        else:
            # 仍然是用队列的方式实现遍历，末端按遍历顺序逐个添加节点，首端逐个弹出先读到的节点
            queue = []
            queue.append(self.root)
            while queue:
                cur = queue.pop(0)
                print(cur.item, end = " ")
                if cur.lchild is not None:
                    queue.append(cur.lchild)
                if cur.rchild is not None:
                    queue.append(cur.rchild)
    # 定义深度优先遍历中的先序遍历
    def preorder(self, node):
        if node == None:
            return 
        else:
            print(node.item, end = " ")
            self.preorder(node.lchild)
            self.preorder(node.rchild)
    # 定义深度优先遍历中的中序遍历
    def inorder(self, node):
        if node == None:
            return
        else:
            self.inorder(node.lchild)
            print(node.item, end = " ")
            self.inorder(node.rchild)
    # 定义深度优先遍历中的后序遍历
    def postorder(self, node):
        if node == None:
            return
        else:
            self.postorder(node.lchild)
            self.postorder(node.rchild)
            print(node.item, end = " ")

测试：

if __name__ == "__main__":
    t = Tree()
    t.add(0)
    t.add(1)
    t.add(2)
    t.add(3)
    t.add(4)
    t.add(5)
    t.add(6)
    t.add(7)
    t.add(8)
    t.add(9)
    t.breadth_travel()
    print("")
    t.preorder(t.root)
    print("")
    t.inorder(t.root)
    print("")
    t.postorder(t.root)
    print("")

运行一下：

0 1 2 3 4 5 6 7 8 9
0 1 3 7 8 4 9 2 5 6
7 3 8 1 9 4 0 5 2 6
7 8 3 9 4 1 5 6 2 0