数据结构笔记：二叉树

原文地址

分类目录——数据结构笔记

二叉树：每个节点最多含有两个子树的树称为二叉树

• 二叉树的性质

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

• 完全二叉树

  设若二叉树的高度为h，除第h层外，其他各层（1~h-1）的节点都达到最大个数，第h层有叶子结点，并且叶子节点都是从左到右依次排布

• 满二叉树

  出了叶子结点外每一个结点都有左右自叶且叶子结点都处在最底层的二叉树

• 二叉树的实现

  • 结点实现

    class Node(object):
        def __init__(self, elem=-1, lchild=None, rchild=None):
            self.elem = elem
            self.lchild = lchild
            self.rchild = rchild
    

  • 二叉树类及其方法的实现

    树的遍历

    • 先序/先根遍历：根左右
    • 中序遍历：左根右
    • 后序遍历：左右根

    树的还原

    ​ 可以根据遍历序列还原出原树的结构，要完成遍历，至少需要中序遍历及先序遍历或后序遍历中的一个

    class BinaryTree(object):
        def __init__(self):
            self.root = None
    
        def add(self, item):
            '''向二叉树中追加元素'''
            node = Node(item)
            if self.root is None:
                self.root = node
                return
            queue = [self.root]  # 相当于直接用队列的内部实现机理来处理
            # 直到出现第一个空位置，（这是一个完全二叉树）
            while queue:
                cur_node = queue.pop(0)  # 把低位当做队列的出口
                if cur_node.lchild is None:
                    cur_node.lchild = node
                    return
                else:
                    queue.append(cur_node.lchild)  # 层次遍历，如果不为空，加进去
                if cur_node.rchild is None:
                    cur_node.rchild = node
                    return
                else:
                    queue.append(cur_node.rchild)  # 层次遍历，如果不为空，加进去
    
        def breadth_travel(self):
            '''广度优先遍历'''
            if self.root is None:
                return
            queue = [self.root]
    
            while queue:
                cur_node = queue.pop(0)
                print(cur_node.elem, end=' ')
                if not cur_node.lchild is None:
                    queue.append(cur_node.lchild)
                if not cur_node.rchild is None:
                    queue.append(cur_node.rchild)
    
        def preorder(self, rootnode):
            '''先序遍历'''
            if rootnode is None:
                return
            print(rootnode.elem, end=' ')
            self.preorder(rootnode.lchild)
            self.preorder(rootnode.rchild)
    
        def inorder(self, rootnode):
            '''中序遍历'''
            if rootnode is None:
                return
            self.inorder(rootnode.lchild)
            print(rootnode.elem, end=' ')
            self.inorder(rootnode.rchild)
    
        def postorder(self, rootnode):
            '''后续遍历'''
            if rootnode is None:
                return
            self.postorder(rootnode.lchild)
            self.postorder(rootnode.rchild)
            print(rootnode.elem, end=' ')
    

  • 测试

    if __name__ == '__main__':
        tree = BinaryTree()
        tree.add(0)
        tree.add(1)
        tree.add(2)
        tree.add(3)
        tree.add(4)
        tree.add(5)
        tree.add(6)
        tree.add(7)
        tree.add(8)
        tree.add(9)
        tree.breadth_travel()
        print()
        tree.preorder(tree.root)
        print()
        tree.inorder(tree.root)
        print()
        tree.postorder(treeroot)
        print()