【学习笔记】数据结构与算法05:树、层序遍历、深度优先搜索、二叉搜索树

知识出处:Hello算法:https://www.hello-algo.com/

文章目录

    • [2.4 树](#2.4 树)
      • [2.4.1 「二叉树 binary tree」](#2.4.1 「二叉树 binary tree」)
        • [2.4.1.1 二叉树基本操作](#2.4.1.1 二叉树基本操作)
        • [2.4.1.2 二叉树的常见类型](#2.4.1.2 二叉树的常见类型)
          • [「完美二叉树 perfect binary tree」](#「完美二叉树 perfect binary tree」)
          • [「完全二叉树 complete binary tree」](#「完全二叉树 complete binary tree」)
          • [「完满二叉树 full binary tree」](#「完满二叉树 full binary tree」)
          • [「平衡二叉树 balanced binary tree」](#「平衡二叉树 balanced binary tree」)
        • [2.4.1.3 二叉树的退化&进化](#2.4.1.3 二叉树的退化&进化)
      • [2.4.2 二叉树遍历](#2.4.2 二叉树遍历)
      • [2.4.3 二叉树数组表示](#2.4.3 二叉树数组表示)
        • [2.4.3.1 数组表示完美二叉树](#2.4.3.1 数组表示完美二叉树)
        • [2.4.3.2 数组表示任意二叉树](#2.4.3.2 数组表示任意二叉树)
        • [2.4.3.3 优点与局限性](#2.4.3.3 优点与局限性)
      • [2.4.4 二叉搜索树](#2.4.4 二叉搜索树)
        • [2.4.4.1 二叉搜索树的搜索操作](#2.4.4.1 二叉搜索树的搜索操作)
        • [2.4.4.2 搜索二叉树的效率](#2.4.4.2 搜索二叉树的效率)
        • [2.4.4.3 二叉搜索树常见应用](#2.4.4.3 二叉搜索树常见应用)

2.4 树

2.4.1 「二叉树 binary tree」

二叉树 binary tree是一种非线性数据结构,代表"祖先"与"后代"之间的派生关系,体现了"一分为二"的分治逻辑。与链表类似,二叉树的基本单元是节点,每个节点包含值、左子节点引用和右子节点引用

java 复制代码
/* 二叉树节点类 */
class TreeNode {
    int val;         // 节点值
    TreeNode left;   // 左子节点引用
    TreeNode right;  // 右子节点引用
    TreeNode(int x) { val = x; }
}
  • 每个节点都有两个引用(指针),分别指向「左子节点 left-child node」和「右子节点 right-child node」

  • 该节点自身被称为这两个子节点的「父节点 parent node」.

  • 当给定一个二叉树的节点时,我们将该节点的左子节点及其以下节点形成的树称为该节点的「左子树 left subtree」,同理可得「右子树 right subtree」。

  • 在二叉树中,除叶节点外,其他所有节点都包含子节点和非空子树。也就是说,不包含子节点的节点就被称为「叶节点 leaf node」

二叉树的常用术语如图所示。

  • 「根节点 root node」:位于二叉树顶层的节点,没有父节点。
  • 「叶节点 leaf node」:没有子节点的节点,其两个指针均指向 None
  • 「边 edge」:连接两个节点的线段,即节点引用(指针)。
  • 节点所在的「层 level」:从顶至底递增,根节点所在层为 1 。
  • 节点的「度 degree」:节点的子节点的数量。在二叉树中,度的取值范围是 0、1、2 。
  • 二叉树的「高度 height」:从根节点到最远叶节点 所经过的边的数量
  • 节点的「深度 depth」:从根节点到该节点所经过的边的数量。
  • 节点的「高度 height」:从距离该节点最远的叶节点 到该节点所经过的边的数量。

Tip:

  • 请注意,我们通常将"高度"和"深度"定义为"经过的边的数量",但有些题目或教材可能会将其定义为"经过的节点的数量"。在这种情况下,高度和深度都需要加 1 。
  • 如何理解深度和高度?
    • 深度是根部到该节点的举例,高度是该节点到叶节点的距离
    • 深度可以表示找到这个节点需要花费的时间,深度越深,找到这个节点就经过更多边,也需要更多时间。可以用于判断"查询"操作所需的时间
    • 高度可以表示从这个节点到最外层需要花费的时间,高度越高,找到叶节点的时间就需要花费更多时间。可以用于判断遍历"该子树所有节点"所需的时间。
    • 另外,深度只能描述某个节点的深度,而高度既可以直接表示树,也可以描述某个节点。
2.4.1.1 二叉树基本操作

初始化

与链表类似,首先初始化节点,然后构建引用(指针)。

插入与删除节点

与链表类似,在二叉树中插入与删除节点可以通过修改指针来实现

注意:

插入节点可能会改变二叉树的原有逻辑结构,而删除节点通常意味着删除该节点及其所有子树。因此,在二叉树中,插入与删除通常是由一套操作配合完成的,以实现有实际意义的操作。

2.4.1.2 二叉树的常见类型
「完美二叉树 perfect binary tree」

完美二叉树(又称"满二叉树")是所有层的节点都被完全填满的二叉树,具有以下特点:

  • 所有叶节点的度都为0,且其余所有节点都为0;
  • 若树的高度为h,则节点总数为 2^h+1^−1 。呈指数级关系,反应了自然界中的细胞分裂现象。
「完全二叉树 complete binary tree」

只有最底层的节点未被填满,且最底层节点尽量靠左填充。

之前被忽略的类型,实际上这样的二叉树可以直接使用数组进行表示,需要有将一维序列转换换位二维序列的思维能力。

「完满二叉树 full binary tree」

除了叶节点之外,其余所有节点都有两个子节点。

「平衡二叉树 balanced binary tree」

任意节点的左子树和右子树的高度之差的绝对值不超过 1 。

2.4.1.3 二叉树的退化&进化

当二叉树的每层节点都被填满时,达到"完美二叉树";而当所有节点都偏向一侧时,二叉树退化为"链表"。

在最佳结构和最差结构下,二叉树的叶节点数量、节点总数、高度等达到极大值或极小值。

关于二叉树演变的个人理解

  • 链表可以看成"所有节点的度都为1的二叉树",是一种特化的二叉树,理论上适用于二叉树的计算公式,也适用于链表。反过来,链表拥有的部分特点在会在二叉树上实现。
  • 二叉树的几种常用类型也有自身的演化过程:
    1. 平衡二叉树(左子树和右子树相差不大即可
    2. 圆满二叉树(非叶节点都有两个子节点)
    3. 完全二叉树(在圆满二叉树的基础上,要求节点都靠左)
    4. 完美二叉树(在完全二叉树的基础上,要求叶节点这层的节点都必须被填满)

2.4.2 二叉树遍历

链表的遍历方式是通过指针逐个访问节点。然而,从物理结构的角度来看,树是一种基于链表的非线性数据结构,这使得遍历树比遍历链表更加复杂,需要借助搜索算法来实现。

二叉树常见的遍历方式包括层序遍历、前序遍历、中序遍历和后序遍历等。(手敲代码帮助理解)

2.4.2.1 层序遍历 level-order traversal

从顶部到底部逐层遍历二叉树,并在每一层按照从左到右的顺序访问节点。

层序遍历本质上属于**「广度优先遍历 breadth-first traversal」,也称「广度优先搜索 breadth-first search, BFS」**,它体现了一种"一圈一圈向外扩展"的逐层遍历方式。

代码

广度优先遍历通常借助"队列"来实现。

实现思路如下:

  1. 给出一个队列,先存入根节点; 给出一个列表,用于存储结果
  2. 遍历该队列
    • 节点出队
    • 像列表,存入数值
    • 将出队的节点对应的节点(如有)入队
    • 以此循环
java 复制代码
// 层序遍历
Queue<TreeNode> treeNodeQueue = new ArrayDeque<>();
treeNodeQueue.add(n1);
List<Integer> resList = new ArrayList<>();
while (!treeNodeQueue.isEmpty()){
    TreeNode node = treeNodeQueue.poll();
    resList.add(node.val);
    if (node.left != null){
        treeNodeQueue.add(node.left);
    }
    if (node.right != null){
        treeNodeQueue.add(node.right);
    }
}
复杂度分析
  • 时间复杂度为 O(n) :所有节点被访问一次,使用 O(n) 时间,其中 n 为节点数量。
  • 空间复杂度为 O(n) :在最差情况下,即满二叉树时,遍历到最底层之前,队列中最多同时存在 (n+1)/2 个节点,占用 O(n) 空间。
2.4.2.2 前序、中序和后序遍历(DFS)

相应地,前序、中序和后序遍历都属于**「深度优先遍历 depth-first traversal**」,也称「深度优先搜索 depth-first search, DFS」,它体现了一种"先走到尽头,再回溯继续"的遍历方式。

深度优先遍历就像是绕着整棵二叉树的外围"走"一圈,在每个节点都会遇到三个位置,分别对应前序遍历、中序遍历和后序遍历,

深度优先搜索通常基于递归实现。

递归过程,可分为"递"和"归"两个逆向的部分。

  1. "递"表示开启新方法,程序在此过程中访问下一个节点。
  2. "归"表示函数返回,代表当前节点已经访问完毕。
java 复制代码
public static void main(String[] args) {
    /* 初始化二叉树 */
    // 初始化节点
    TreeNode n1 = new TreeNode(1);
    TreeNode n2 = new TreeNode(2);
    TreeNode n3 = new TreeNode(3);
    TreeNode n4 = new TreeNode(4);
    TreeNode n5 = new TreeNode(5);
    TreeNode n6 = new TreeNode(6);
    TreeNode n7 = new TreeNode(7);
    // 构建节点之间的引用(指针)
    n1.left = n2;
    n1.right = n3;
    n2.left = n4;
    n2.right = n5;
    n3.left = n6;
    n3.right = n7;
    System.out.println("\n初始化二叉树\n");
    PrintUtil.printTree(n1);


    resList.clear();
    preOrder(n1, resList);
    System.out.println(resList);

    resList.clear();
    midOrder(n1, resList);
    System.out.println(resList);
    resList.clear();
    afterOrder(n1, resList);
    System.out.println(resList);
}

/**
     * 前序遍历
     */
static void preOrder(TreeNode node, List<Integer> res) {
    if (node == null) {
        return;
    }
    // 遍历节点本身
    res.add(node.val);
    // 遍历左节点
    preOrder(node.left, res);
    // 遍历右节点
    preOrder(node.right, res);
}

static void midOrder(TreeNode node, List<Integer> res) {
    if (node == null) {
        return;
    }
    // 遍历左节点
    preOrder(node.left, res);
    // 遍历节点本身
    res.add(node.val);
    // 遍历右节点
    preOrder(node.right, res);
}

static void afterOrder(TreeNode node, List<Integer> res) {
    if (node == null) {
        return;
    }
    // 遍历左节点
    preOrder(node.right, res);
    // 遍历右节点
    preOrder(node.left, res);
    // 遍历节点本身
    res.add(node.val);
}
深度优先遍历基于迭代的方式实现

力扣找到的解法:解答思路

我们也可以用迭代的方式实现方法一的递归函数,两种方式是等价的,区别在于递归的时候隐式地维护了一个栈 ,而我们在迭代的时候需要显式地将这个栈模拟出来,其余的实现与细节都相同,具体可以参考下面的代码。

java 复制代码
Stack<TreeNode> stack = new Stack<>();
TreeNode node = n1;
List<Integer> res = new ArrayList<Integer>();
while (!stack.isEmpty() || node != null) {
    while (node != null) {
        res.add(node.val);
        stack.push(node);
        node = node.left;
    }
    node = stack.pop();
    node = node.right;
}

2.4.3 二叉树数组表示

2.4.3.1 数组表示完美二叉树

原文中给出的图非常直观的展示了数组如何表示二叉树

2.4.3.2 数组表示任意二叉树

在上面的基础上,显式地写出所有 None

综上不难发现,,完全二叉树非常适合使用数组来表示 。回顾完全二叉树的定义,None 只出现在最底层且靠右的位置,因此所有 None 一定出现在层序遍历序列的末尾

代码实现

尝试用List<Integer>来表示的二叉树,实现以下操作:

  • 给定某节点,获取它的值、左(右)子节点、父节点。
  • 获取前序遍历、中序遍历、后序遍历、层序遍历序列。
2.4.3.3 优点与局限性

二叉树的数组表示主要有以下优点。

  • 数组存储在连续的内存空间中,对缓存友好,访问与遍历速度较快。
  • 不需要存储指针,比较节省空间。
  • 允许随机访问节点

然而,数组表示也存在一些局限性。

  • 数组存储需要连续内存空间,因此不适合存储数据量过大的树。
  • 增删节点需要通过数组插入与删除操作实现,效率较低。
  • 当二叉树中存在大量 None 时,数组中包含的节点数据比重较低,空间利用率较低。

2.4.4 二叉搜索树

「二叉搜索树 binary search tree」满足以下条件。

  1. 对于根节点,左子树中所有节点的值 < 根节点的值 < 右子树中所有节点的值。
  2. 任意节点的左、右子树也是二叉搜索树,即同样满足条件 1.

和"堆"的概念近似,也要做出区分。

  • 「小顶堆 min heap」:任意节点的值 ≤ 其子节点的值。
  • 「大顶堆 max heap」:任意节点的值 ≥ 其子节点的值。

个人理解:

  • 二叉搜索树体现了二分算法的思想
2.4.4.1 二叉搜索树的搜索操作
查询

给定目标节点值 num ,可以根据二叉搜索树的性质来查找。如图 7-17 所示,我们声明一个节点 cur ,从二叉树的根节点 root 出发,循环比较节点值 cur.valnum 之间的大小关系。

  • cur.val < num ,说明目标节点在 cur 的右子树中,因此执行 cur = cur.right
  • cur.val > num ,说明目标节点在 cur 的左子树中,因此执行 cur = cur.left
  • cur.val = num ,说明找到目标节点,跳出循环并返回该节点。
插入节点

插入节点时需要注意保持二叉搜索树"左子树 < 根节点 < 右子树"的性质

  1. 需要查询插入位置:和查询操作类似,从根节点触发,直到叶节点(遍历至 None )时跳出循环。
  2. 在该位置插入节点 :初始化节点 num ,将该节点置于 None 的位置。

插入时需要注意:

  • 二叉搜索树不允许存在重复节点,否则将违反其定义。因此,若待插入节点在树中已存在,则不执行插入,直接返回。

删除节点

删除节点需要区分三种情况,分别是节点的度为0/1/2时,进行的操作是不同的

  • 度为0时,节点是叶节点,直接删除
  • 度为1时,该节点只有一个叶节点(高度为1),将待删除节点 替换为其子节点即可。
  • 当待删除节点的度为 2 时,我们无法直接删除它,而需要使用一个节点替换该节点。由于要保持二叉搜索树"左子树 < 根节点 < 右子树"的性质,因此这个节点可以是右子树的最小节点或左子树的最大节点
中序遍历

由于二叉搜索树的特性,中序遍历遵循"左 → 根 → 右"的遍历顺序,而二叉搜索树满足"左子节点 < 根节点 < 右子节点"的大小关系。从而得出一个重要性质:二叉搜索树的中序遍历序列是升序的

利用中序遍历升序的性质,我们在二叉搜索树中获取有序数据仅需 O(n) 时间,无须进行额外的排序操作,非常高效。

2.4.4.2 搜索二叉树的效率

对比无序数组和二叉搜索树。

无序数组 二叉搜索树
查找元素 O(n) O(log⁡n)
插入元素 O(1) O(log⁡n)
删除元素 O(n) O(log⁡n)
  • 二叉搜索树的各项操作的时间复杂度都是对数阶,具有稳定且高效的性能。可以得出二叉搜索树是"平衡"的(理想状态下
  • 比较之下,二叉搜索树在查询和删除元素时有较大优势。
  • 只有在高频添加、低频查找删除数据的场景下,数组比二叉搜索树的效率更高。.
  • 如果我们在二叉搜索树中不断地插入和删除节点,各种操作的时间复杂度也会退化为 O(n) 。
2.4.4.3 二叉搜索树常见应用
  • 用作系统中的多级索引,实现高效的查找、插入、删除操作。
  • 作为某些搜索算法的底层数据结构。
  • 用于存储数据流,以保持其有序状态。

由于劣化的现象存在,所以在实际业务场景中是比较少见的。

为了解决二叉搜索树会劣化的问题,后续基于二叉搜索树给出了更优的算法

  • 比如平衡二叉树(AVL树),通过一系列操作,确保在持续添加和删除节点后,AVL 树不会退化。AVL 树¶
  • 还有非常出名的红黑树------自平衡的二叉查找树 具体可以看看文章

2.5 堆

相关推荐
幼儿园老大*35 分钟前
走进 Go 语言基础语法
开发语言·后端·学习·golang·go
Selina K37 分钟前
shell脚本知识点记录
笔记·shell
1 小时前
开源竞争-数据驱动成长-11/05-大专生的思考
人工智能·笔记·学习·算法·机器学习
ctrey_1 小时前
2024-11-4 学习人工智能的Day21 openCV(3)
人工智能·opencv·学习
啦啦右一1 小时前
前端 | MYTED单篇TED词汇学习功能优化
前端·学习
霍格沃兹测试开发学社测试人社区2 小时前
软件测试学习笔记丨Flask操作数据库-数据库和表的管理
软件测试·笔记·测试开发·学习·flask
今天我又学废了2 小时前
Scala学习记录,List
学习
幸运超级加倍~2 小时前
软件设计师-上午题-16 算法(4-5分)
笔记·算法
王俊山IT2 小时前
C++学习笔记----10、模块、头文件及各种主题(一)---- 模块(5)
开发语言·c++·笔记·学习
Mephisto.java3 小时前
【大数据学习 | kafka高级部分】kafka中的选举机制
大数据·学习·kafka