python高阶-二叉树

欢迎观看、欢迎指正、共同学习

树

树是一种非线性结构
定义:用来模拟具有树状结构性质的数据集合
特点:
    1、每个节点有零个或多个子节点
    2、没有父节点的节点称为根节点
    3、每一个非根节点有且只有一个父节点
    4、除了根节点外，每个子节点可以分为多个不相交的子树
术语:
    1、节点的度：一个节点含有的子节点的个数称为该节点的度
    2、树的度：一棵树中，最大的节点的度称为树的度
    3、叶节点或终端节点：度为零的节点
    4、父亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点
    5、孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点
    6、兄弟节点：具有相同父节点的节点互称为兄弟节点
    7、节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推
    8、树的高度或深度：树中节点的最大层次
    9、堂兄弟节点：父节点在同一层的节点互为堂兄弟
    10、节点的祖先：从根到该节点所经分支上的所有节点
    11、子孙：以某节点为根的子树中任一节点都称为该节点的子孙
    12、森林：由m（m>=0）棵互不相交的树的集合称为森林

应用场景:
	1、xml，html等
	2、路由协议就是使用了树的算法
	3、mysql数据库索引
	4、文件系统的目录结构
	5、很多经典的AI算法其实都是树搜索
注意:大量、海量数据通过树存储，会加快检索速度。

树的种类

不同种类的树有不同的作用
种类
    1、有序树：树中任意节点的子节点之间没有顺序关系
    	霍夫曼树（用于信息编码）：带权路径最短的二叉树称为哈夫曼树或最优二叉树
		B树：一种对读写操作进行优化的自平衡的二叉查找树，能够保持数据有序，拥有多于两个的子树
    2、无序树：树中任意节点的子节点之间有顺序关系
    3、二叉树:每个节点最多含有两个子树的树

二叉树

种类:
    1、完全二叉树：除了第d(d>1)层外，其它各层的节点数目均已达最大值，且第d层所有节点从左向右连续地紧密排列，这样的二叉树被称为完全二叉树，其中满二叉树的定义是所有叶节点都在最底层的完全二叉树
    2、平衡二叉树:当且仅当任何节点的两棵子树的高度差不大于1的二叉树
    3、排序二叉树
            要求:
            1.若左子树不空，则左子树上所有节点的值均小于它的根节点的值
            2.若右子树不空，则右子树上所有节点的值均大于它的根节点的值
            3.左、右子树也分别为二叉排序树
二叉树的存储:
	1、顺序存储
	2、链式存储
性质:
	性质1: 在二叉树的第i层上至多有 2i次方-1 个结点（i>0）
	性质2: 深度为k的二叉树至多有2k - 1个结点（k>0）
	性质3: 对于任意一棵二叉树，如果其叶结点数为N_0，而度数为2的结点总数为N_2 ，则N_0 = N_2+1
	性质4: 最多有n个结点的完全二叉树的深度必为 log2(n+1)
	性质5: 对完全二叉树，若从上至下、从左至右编号，则编号为i 的结点，其左孩子编号必为2i，其右孩子编号必为2i＋1 , 其父节点的编号必为i//2（i＝1 时为根,除外）

二叉树广度优先遍历及三种深度遍历

yum:在线安装
rpm:离线安装
三种深度优先遍历:
	1、先序:根左右
	2、中序:左根右
	3、后序:左右根

# 1.先定义类
# 定义节点类
class Node:
    def __init__(self, item):
        self.item = item
        self.lchild = None
        self.rchild = None

# 定义树类
class TwoXTree:
    def __init__(self):
        self.root = None

    # 定义添加节点方法
    # 注意: 只要添加成功就结束当前函数
    def add(self, item):
        # 1.先判断树的根节点是否为空
        if self.root is None:
            self.root = Node(item)  # A
            print(f'添加节点位置1,添加了{item}')
            return
        # 2.如果根节点存在了,后续需要再添加元素,需要判断左右
        # 提前创建临时列表作为队列使用,以后从此队列中取出节点判断存放位置
        queue = [self.root]
        # 3.遍历队列,从队列中取出第一个元素,直到队列为空
        # 注意: 边取边判断,同时再把最新节点放到队列中
        while True:
            # 取出队列中第一个元素(默认第一次是根节点,后面就是根节点的孩子们了...)
            node = queue.pop(0)
            # 如果当前节点左孩子为空,就把item所在节点添加到左孩子中,结束当前函数
            if node.lchild is None:
                node.lchild = Node(item)  # B D F H J
                print(f'添加节点位置2,添加了{item}')
                return
            # 如果当前节点右孩子为空,就把item所在节点添加到右孩子中,结束当前函数
            elif node.rchild is None:
                node.rchild = Node(item)  # C E G I
                print(f'添加节点位置3,添加了{item}')
                return
            else:
                queue.append(node.lchild)
                queue.append(node.rchild)

    # 定义广度优先遍历方法
    def breadth_travel(self):
        # 1.先判断根节点是否为空,如果为空就没有遍历的必要了
        if self.root is None:
            print('对不起,二叉树为空,不能遍历')
            return
        # 创建队列,把根节点放入队列
        queue = [self.root]  # []
        # 遍历队列,直到队列为空
        while len(queue) > 0:
            # 取出队列第一个元素
            node = queue.pop(0)
            # 打印元素
            print(node.item, end=' ')  # A B C D E F G H I J
            # 判断左孩子是否存在,存在就放入队列
            if node.lchild is not None:
                queue.append(node.lchild)
            if node.rchild is not None:
                queue.append(node.rchild)
        # 换行
        print()

    # 定义深度优先遍历方法
    """
    注意: 深度优先有三种遍历方式: 
    先序(根左右):ABDHIEJCFG
    中序(左根右):HDIBJEAFCG
    后序(左右根):HIDJEBFGCA
    递归思想: 函数内部自己调用自己,注意:必须有出口!!!
    """

    # 先序(根左右): ABDHIEJCFG
    def pre_travel(self, root):
        # 注意:首次root是根节点,后续就是它的孩子们...
        if root is not None:
            # 根
            print(root.item, end=' ')
            # 左
            self.pre_travel(root.lchild)
            # 右
            self.pre_travel(root.rchild)

    # 中序(左根右): HDIBJEAFCG
    def in_travel(self, root):
        # 注意:首次root是根节点,后续就是它的孩子们...
        if root is not None:
            # 左
            self.in_travel(root.lchild)
            # 根
            print(root.item, end=' ')
            # 右
            self.in_travel(root.rchild)

    # 后序(左右根): HIDJEBFGCA
    def back_travel(self, root):
        # 注意:首次root是根节点,后续就是它的孩子们...
        if root is not None:
            # 左
            self.back_travel(root.lchild)
            # 右
            self.back_travel(root.rchild)
            # 根
            print(root.item, end=' ')


if __name__ == '__main__':
    # 2.再根据类创建对象
    tree = TwoXTree()
    # 3.使用对象
    # 测试添加功能
    tree.add('A')
    tree.add('B')
    tree.add('C')
    tree.add('D')
    tree.add('E')
    tree.add('F')
    tree.add('G')
    tree.add('H')
    tree.add('I')
    tree.add('J')
    print('---------------------------------')
    # 测试广度优先遍历功能
    tree.breadth_travel()
    print('---------------------------------')
    # 测试深度优先遍历功能
    # 先序(根左右): ABDHIEJCFG
    tree.pre_travel(tree.root)
    print()

    # 中序(左根右): HDIBJEAFCG
    tree.in_travel(tree.root)
    print()

    # 后序(左右根): HIDJEBFGCA
    tree.back_travel(tree.root)
    print()