数据结构与算法 | 二叉树

最新推荐文章于 2024-03-09 19:36:56 发布

写代码的阿呆

最新推荐文章于 2024-03-09 19:36:56 发布

阅读量547

点赞数

分类专栏： Python 数据结构与算法文章标签：二叉树二叉树添加元素二叉树遍历

本文链接：https://blog.csdn.net/qq_27782503/article/details/95889336

版权

Python 同时被 2 个专栏收录

86 篇文章 6 订阅

订阅专栏

数据结构与算法

29 篇文章 0 订阅

订阅专栏

什么叫树？二叉树？Python实现？

1 什么叫树
2 树的术语
3 树的种类
4 数的存储方式
5 树的应用场景
6 二叉树
- 6.1 概念
- 6.2 性质
7 代码实现二叉树
8 给出一个序列如何画出树
参考

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$ 层上至多有 $2^(i-1)$ 个结点（ $i > 0$ ）
性质2: 深度为 $k$ 的二叉树至多有 $2^k - 1$ 个结点（ $k > 0$ ）
性质3: 对于任意一棵二叉树，如果其叶结点数为 $N_0$ ，而度数为2的结点总数为 $N_2$ ，则 $N_0=N_2+1$ ;
性质4:具有 $n$ 个结点的完全二叉树的深度必为 $l o g 2 (n + 1)$
性质5:对完全二叉树，若从上至下、从左至右编号，则编号为 $i$ 的结点，其左孩子编号必为 $2 i$ ，其右孩子编号必为 $2 i ＋ 1$ ；其双亲的编号必为 $\frac{i}{2}$ （ $i ＝ 1$ 时为根,除外）

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，再搭配其余的！

参考

b站视频：https://www.bilibili.com/video/av53583801/?p=50