数据结构与算法 | 二叉树

1 什么叫树

  • 树(英语:tree)是一种抽象数据类型(ADT)或是实作这种抽象数据类型的数据结构,用来模拟具有树状结构性质的数据集合
  • 它是由n(n>=1)个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。它具有以下的特点:
    • 每个节点有零个或多个子节点;
    • 没有父节点的节点称为根节点;
    • 每一个非根节点有且只有一个父节点;【即只有一个爸爸…】
    • 除了根节点外,每个子节点可以分为多个不相交的子树;【可以有多个孩子】
  • 举例:
    在这里插入图片描述

2 树的术语

  • 节点的度:一个节点含有的子树的个数称为该节点的度;【子节点的个数】
  • 树的度:一棵树中,最大的节点的度称为树的度;【比较所有节点的度 取最大】
  • 叶节点或终端节点:度为零的节点;【到头了】
  • 父亲节点或父节点:若一个节点含有子节点,则这个节点称为其子节点的父节点;【你的唯一上级】
  • 孩子节点或子节点:一个节点含有的子树的根节点称为该节点的子节点;【你的下级】
  • 兄弟节点:具有相同父节点的节点互称为兄弟节点;【同一个父亲的】
  • 节点的层次:从根开始定义起,根为第1层,根的子节点为第2层,以此类推;【一层一层】
  • 树的高度或深度:树中节点的最大层次;【最大层次达到多少 就是深度 取最大!】
  • 堂兄弟节点:父节点在同一层的节点互为堂兄弟;【同一个爷爷。。。】
  • 节点的祖先:从根到该节点所经分支上的所有节点;【所有的上级都是它祖先】
  • 子孙:以某节点为根的子树中任一节点都称为该节点的子孙。【和祖先反过来】
  • 森林:由m(m>=0)棵互不相交的树的集合称为森林;

3 树的种类

  • 无序树:树中任意节点的子节点之间没有顺序关系,这种树称为无序树,也称为自由树;【没有任何研究价值!】
  • 有序树:树中任意节点的子节点之间有顺序关系,这种树称为有序树;【有价值去研究!】
    • 二叉树:每个节点最多含有两个子树的树称为二叉树;【一个节点最多只能分两个叉!】
      • 完全二叉树【最深层以上均满】:对于一颗二叉树,假设其深度为d(d>1)。除了第d层外,其它各层的节点数目均已达最大值,且第d层所有节点从左向右连续地紧密排列,这样的二叉树被称为完全二叉树,其中满二叉树【所有均满】的定义是所有叶节点都在最底层的完全二叉树;
        在这里插入图片描述
        在这里插入图片描述
      • 平衡二叉树(AVL树)【从定义理解 即一个节点的两个分叉不能大于1】:当且仅当任何节点的两棵子树的高度差不大于1的二叉树;
      • 排序二叉树(二叉查找树(英语:Binary Search Tree),也称二叉搜索树、有序二叉树)【节点值处于中间,左边小于它,右边大于它】-【查找的时候其实就是二分查找!】;
    • 霍夫曼树(用于信息编码):带权路径最短的二叉树称为哈夫曼树或最优二叉树;
    • B树:一种对读写操作进行优化的自平衡的二叉查找树,能够保持数据有序,拥有多余两个子树。

4 数的存储方式

主要有两种方式进行存储:

  • 顺序存储:将数据结构存储在固定的数组中,然在遍历速度上有一定的优势,但因所占空间比较大,是非主流二叉树。二叉树通常以链式存储。见下图
    在这里插入图片描述
  • 链式存储:见下图

由于对节点的个数无法掌握,常见树的存储表示都转换成二叉树进行处理,子节点个数最多为2
在这里插入图片描述

5 树的应用场景

  • xml,html等,那么编写这些东西的解析器的时候,不可避免用到树
  • 路由协议就是使用了树的算法
  • mysql数据库索引
  • 文件系统的目录结构
  • 很多经典的AI算法其实都是树搜索,此外机器学习中的decision tree也是树结构

6 二叉树

6.1 概念

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

6.2 性质

  • 性质1: 在二叉树的第 i i i层上至多有 2 ( i − 1 ) 2^(i-1) 2(i1)个结点( i > 0 i>0 i>0
  • 性质2: 深度为 k k k的二叉树至多有 2 k − 1 2^k - 1 2k1个结点( k > 0 k>0 k>0
  • 性质3: 对于任意一棵二叉树,如果其叶结点数为 N 0 N_0 N0,而度数为2的结点总数为 N 2 N_2 N2,则 N 0 = N 2 + 1 N_0=N_2+1 N0=N2+1;
  • 性质4:具有 n n n个结点的完全二叉树的深度必为 l o g 2 ( n + 1 ) log2(n+1) log2(n+1)
  • 性质5:对完全二叉树,若从上至下、从左至右编号,则编号为 i i i 的结点,其左孩子编号必为 2 i 2i 2i,其右孩子编号必为 2 i + 1 2i+1 2i1;其双亲的编号必为 i 2 \frac{i}{2} 2i i = 1 i=1 i1时为根,除外)

7 代码实现二叉树

7.1 定义二叉树的节点

class Node(object):
    '''二叉树的结点'''
    
    def __init__(self, item):
        self.elem = item
        # 左孩子和右孩子!
        self.lchild = None
        self.rchild = None

7.2 往二叉树添加元素

思路:

  • 二叉树的添加元素对应的数据结构是队列,先进先出!后进后出!
  • 首先添加毫无疑问是根节点!记得初始化
  • 然后就是分三步去判断:
    • 首先看根节点是否为空 如果是 添加 返回即可 如果不是 放入队列
    • 如果根节点非空,判断其左子节点是否为空 如果为空 添加元素 返回空 如果非空 添加到队列
    • 如果根节点非空+左子节点非空,判断其右子节点是否为空 如果为空 添加元素 返回空 如果非空 添加到队列
  • 循环终止条件则是队列为空了 就不再继续
class Tree(object):
    '''构建二叉树'''
    # 链表有首节点 而二叉树有根节点!
    def __init__(self):
        # 保存根节点
        self.root = None
    
    def add(self, item):
        '''每次考虑最后添加'''
        # 先构造节点
        node = Node(item)
        if self.root is None:
            self.root = node
            return  # 为什么加return呢?因为已经完成了add的操作了!所以直接返回就ok了!不要继续纠缠了!
        # 下面的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)

7.3 二叉树的遍历

因为二叉树不是线性结构,所以遍历的方式存在不同!具体来说二叉树的遍历可以从两种不同角度来进行分类:

  • 节点之间位置关系的角度来看,二叉树遍历可分为:(名字和根的顺序一致)
    • 前序遍历。→左→右
    • 中序遍历。左→→右
    • 后续遍历。左→右→
    • 层序遍历。一层一层的遍历,这层结束到下层,一层按照根→左→右
  • 宏观角度看,可分为:
    • 深度优先遍历。(包括上述3种:前序遍历,中序遍历,后续遍历)
    • 广度优先遍历。(层序遍历)
class Tree(object):
    '''构建二叉树'''
    # 链表有首节点 而二叉树有根节点!
    def __init__(self):
        # 保存根节点
        self.root = None
    
    def add(self, item):
        '''每次考虑最后添加'''
        # 先构造节点
        node = Node(item)
        if self.root is None:
            self.root = node
            return  # 为什么加return呢?因为已经完成了add的操作了!所以直接返回就ok了!不要继续纠缠了!
        # 下面的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 cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)
    
    def preorder(self, node):
        '''先序遍历
        - 一开始判断根节点是否为空 如果为空 返回空
        - 若根节点非空 打印节点的元素
        - 由于接下来三种:先序,中序,后序都是深度优先遍历!所以涉及到一个递归问题!
        - 接下来三种思路一致 只是调换顺序!
        '''
        if node is None: 
            # 如果是none就退出
            return 
        # 为什么return空呢?因为到最下面一层的时候 即只有两个子节点的时候,它的左右子节点都没有
        # 故需要返回一个值,然后继续下一条语句的执行,也就是打印右边节点的值!所以这就是return的原因!
        print(node.elem, end=' ')
        
        self.preorder(node.lchild)
        
        self.preorder(node.rchild)
        
    def inorder(self, node):
        '''中序遍历'''
        if node is None:
            return
        
        self.inorder(node.lchild)
        print(node.elem, end=' ')
        self.inorder(node.rchild)
        
    def postorder(self, node):
        '''后序遍历'''
        if node is None:
            return
        
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.elem, end=' ')
if __name__ == '__main__':
    tree = Tree()
    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)
    print('广度优先遍历:')
    tree.breadth_travel()
    print(' ')
    print('先序遍历:')
    tree.preorder(tree.root)
    print(' ')
    print('中序遍历:')
    tree.inorder(tree.root)
    print(' ')
    print('后序遍历:')
    tree.postorder(tree.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  

7.4 知识点补充

  • 以下元素代表空:’ ’ None 等等
  • 如果列表中只要有元素,而我们是对列表进行判断的,即使这个元素为None,也是非空!
bool([None]) # 对list整体考虑 有元素就非空 即使这个元素为None
True
bool(None)
False

8 给出一个序列 如何画出树

给出:

  • 先序遍历
  • 中序遍历
  • 后续遍历

一定要给出中序!

比如给出先序和中序,写出后序!只要给出中序就ok,再搭配其余的!

参考

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值