TypeScript_树结构-BST树

news2024/12/28 19:44:42

树结构

树的特点

  • 树通常有一个根。连接着根的是树干
  • 树干到上面之后会进行分叉成树枝，树枝还会分又成更小的树枝
  • 在树枝的最后是叶子

树的抽象

  • 树可以模拟生活中的很多场景，比如：公司组织架构、家谱、DOM Tree、电脑文件夹架构

优秀的哈希函数（补充）

  • 快速计算：霍纳法则
  • 均匀分布：质数（长度、幂的底）

数据结构对比

数组

  • 优点
    • 数组的主要优点是根据 下标值访问 效率会很高
    • 但是如果我们希望根据元素来查找对应的位置呢？
    • 比较好的方式先对数组进行排序，再进行二分查找
  • 缺点
    • 需要 先对数组进行排序，生成有序数组，才能提高查找效率
    • 另外数组和插入和删除数据时，需要有大量的位移操作（插入到首位或者中间位置的时候）效率很低

链表

  • 优点
    • 链表的插入和删除操作效率都很高
  • 缺点
    • 查找效率很低，需要从头开始依次访问链表中的每个数据项，直到找到
    • 而且即使插入和删除操作操作效率很高，但是如果要插入和删除中间位置的数据，还是需要从头先找到对应的数据

哈希表

  • 优点
    • 哈希表的插入、查询、删除效率都是非常高的
  • 缺点
    • 空间利用率不高，底层使用的数组，并且某些单元是没有被利用的
    • 哈希表中的元素是无序的，不能安装固定的顺序来遍历哈希表中的元素
    • 不能快速的找出哈希表中的 最大值或最小值 这些特殊的值

树

  • 不能说树结构比其他结构都要好，因为 每种数据结构都有自己的特定的应用场景
  • 但是树确实综合了上面的数据结构的优点，并且弥补了上面数据结构的缺点

而且模拟某些场景，我们使用树结构会更加方便

  • 因为数结构的非线性，可以表示一对多的关系
  • 比如：文件的目录结构

树的术语

不过大部分术语都与真实世界的树相关，或者和家庭关系相关(如父节点和子节点)

树（Tree）：n（n>=0）个节点构成的有限集合

  • 当 n=0 时，称为空树

对于任一颗非空树（n>0），它具备以下性质：

  • 树中有一个称为 “根（Root）” 的特殊节点，用 r 表示
  • 其余节点可分为 m（m>0）个互不相交的有限集 T1、T2…Tm，其中每个集合本身又是一棵树，称为原来数的 “子树（SubTree）”

image-20230831092517176

  1. 节点的度（Degree）：节点的子树个数
  2. 树的度（Degree）：树的所有节点的最大度数
  3. 叶节点（Leaf）：度为 0 的节点（也称为叶子节点）
  4. 父节点（Parent）：有子树节点时其子树的根节点的父节点
  5. 子节点（Child）：若 A 节点是 B 节点的父节点，则称 B 节点是 A 节点的子节点，子节点也称孩子节点
  6. 兄弟节点（Sibling）：具有同一父节点的各节点彼此是兄弟节点
  7. 路径和路径长度：从节点 n1 到 nk 的路径为一个节点序列 n1、n2…nk
    • ni 是 n(i+1) 的父节点
    • 路径所包含边的个数为路径的长度
  8. 节点的层次（Level）：规定节点在 1 层，其它任一节点的层数是其父节点的层数+1
  9. 树的深度（Depth）：树中所有节点中的最大层次是这棵树的深度

表示方法

image-20230831094324866

image-20230831094358332

所有的数本质上都可以使用二叉树模拟出来

image-20230831095339522

二叉树

二叉树分类

如果树中每个节点 最多只能有两个子节点，这样的数就称为 “二叉树”

  • 二叉树可以为空，也就是没有节点
  • 若不为空，则它是由根节点和称为其 左子树TL 和 右子树TR 的两个不相交的二叉树组成

image-20230831095734913

二叉树有几个比较重要的特性，笔试题中比较常见：

  • 一颗二叉树第 i 层的最大节点树为：2^(i-1), i>=1
  • 深度为 k 的二叉树有最大节点总数为：2^k-1, k>=1
  • 对任何非空二叉树 T，若 n0 表示叶子点的个数，n2 是度为 2 的非叶节点个数，那么两者满足关系 n0=n2+1

完美二叉树（Perfect Binary Tree），也称满二叉树（Full Binary Tree）

  • 在二叉树中，除了下一层的叶节点外，每层节点都有 2 个子节点，就构成了满二叉树

image-20230831101407988

完全二叉树（Complete Binary Tree）

  • 除二叉树最后一层外，其它各层的节点个数都达到最大个数
  • 最后一层从左到右的叶节点连续存在，只缺右侧若干节点
  • 完美二叉树是特殊的完全二叉树

image-20230831101851096

二叉树存储

二叉树的存储常见的方式是数组和链表

image-20230831102047188

二叉树最常见的方式还是使用链表存储

  • 每个节点封装成一个 Node，Node 中包含存储的数据，左节点的引用，右节点的引用

image-20230831102315370

二叉搜索树

二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树

二叉搜索树是一颗二叉树，可以为空，如果不为空，满足以下性质：

  • 非空左子树的所有键值小于根节点的键值
  • 非空右子树的所有键值大于其根节点的键值
  • 左、右子树本身也都是二叉搜索树

image-20230831144423346

这种方式就是二分查找的思想：

  • 查找所需的最大次数等于二叉搜索树的深度
  • 插入节点，也利用类似的方法，一层层比较大小，找到新节点合适的位置

封装二叉搜索树

常见操作

插入操作：

  • insert(value)：向树中插入一个新的数据

查找操作：

  • search(value)：在树中查找一个数据，如果节点存在，则返回 true；如果不存在，则返回 false
  • min：返回树中最小的值/数据
  • max：返回树中最大的值/数据

遍历操作：

  • inOrderTraverse：通过中序遍历方式遍历所有节点
  • preOrderTraverse：通过先序遍历方式遍历所有节点
  • postOrderTraverse：通过后序遍历方式遍历所有节点
  • levelOrderTraverse：通过层序遍历方式遍历所有节点

删除操作：

  • remove(value)：从树中移除某个数据

插入数据

  1. 插入其他节点时，我们需要判断该值到底是插入到左边还是插入到右边
  2. 判断的依据来自于新节点的 value 和原来节点的 value 值的比较
    • 如果新节点的 newValue 小于原节点的 oldValue，那么就向左边插入
    • 如果新节点的 newValue 大于原节点的 oldValue，那么就向右插入
  3. 代码1位置，就是准备向左子树插入数据，但是它本身有分成两种情况
    • 情况一：左子树上原来没有内容，那么直接插入即可
    • 情况二：左子树上已经有了内容，那么久一次向下继续查找新的走向，所以使用递归调用即可
  4. 代码2位置，和代码1位置几乎逻辑是相同的，只是去向右查找
    • 情况一：左右树上原来没有内容，那么直接插入即可
    • 情况二：右子树上已经有了内容，那么就一次向下继续查找新的走向，所以使用递归调用即可
class BSTree<T> {
  private insertNode(node: TreeNode<T>, newNode: TreeNode<T>) {
    // 代码1
    if (newNode.value < node.value) {
      // 去左边继续查找空白位置
      if (node.left === null) {
        node.left = newNode
      } else {
        this.insertNode(node.left, newNode)
      }
    // 代码2
    } else {
      // 去右边继续查找空白位置
      if (node.right === null) {
        node.right = newNode
      } else {
        this.insertNode(node.right, newNode)
      }
    }
  }
}

遍历数据

  • 遍历一棵树是指访问树的每个节点（也可以对每个节点进行某些操作，我们这里就是简单的打印）
  • 但是树和线性结构不太一样，线性结构我们通常按照从前到后的顺序遍历，但是树呢？
  • 应该从树的顶端还是底端开始呢？从左开始还是从右开始呢？

二叉树遍历常见的四种方式：

  • 先序遍历
  • 中序遍历
  • 后序遍历
  • 层序遍历

image-20230831174022109

先序/中序/后序：取决于访问根节点（root）的时机

  • 在所有的树结构中（包括子树）都是如此

先序遍历

  1. 优先访问根节点
  2. 之后访问左子树
  3. 最后访问右子树

image-20230831180509840

  • 递归版本
class TreeNode<T> extends Node<T> {
  preOrderTraverse() {
    this.preOrderTraverseNode(this.root)
  }
  private preOrderTraverseNode(node: TreeNode<T> | null) {
    if (node) {
      console.log(node.value)
      this.preOrderTraverseNode(node.left)
      this.preOrderTraverseNode(node.right)
    }
  }
}
  • 非递归版本
class TreeNode<T> extends Node<T> {
  preOrderTraversalNoRecursion() {
    let stack: TreeNode<T>[] = []
    let current: TreeNode<T> | null = this.root
    while (current !== null || stack.length !== 0) {
      while (current !== null) {
        console.log(current.value)
        stack.push(current)
        current = current.left
      }
      current = stack.pop()!
      current = current.right
    }
  }
}

中序遍历

  1. 优先访问左子树
  2. 之后访问根节点
  3. 最后访问右子树

image-20230901102713771

  • 递归版本
class TreeNode<T> extends Node<T> {
	inOrderTraverse() {
    this.inOrderTraverseNode(this.root)
  }
  private inOrderTraverseNode(node: TreeNode<T> | null) {
    if (node) {
      this.inOrderTraverseNode(node.left)
      console.log(node.value)
      this.inOrderTraverseNode(node.right)
    }
  }
}
  • 非递归版本
class TreeNode<T> extends Node<T> {
  inOrderTraversalNoRecursion() {
    let stack: TreeNode<T>[] = []
    let current: TreeNode<T> | null = this.root
    while (current !== null || stack.length !== 0) {
      while (current !== null) {
        stack.push(current)
        current = current.left
      }
      current = stack.pop()!
      console.log(current.value)
      current = current.right
    }
  }
}

后序遍历

  1. 优先访问左子树
  2. 之后访问右子树
  3. 最后访问根节点

image-20230901103316974

  • 递归版本
class TreeNode<T> extends Node<T> {
  postOrderTraverse() {
    this.postOrderTraverseNode(this.root)
  }
  private postOrderTraverseNode(node: TreeNode<T> | null) {
    if (node) {
      this.postOrderTraverseNode(node.left)
      this.postOrderTraverseNode(node.right)
      console.log(node.value)
    }
  }
}
  • 非递归版本
class TreeNode<T> extends Node<T> {
  preOrderTraversalNoRecursion() {
    let stack: TreeNode<T>[] = []
    let current: TreeNode<T> | null = this.root
    while (current !== null || stack.length !== 0) {
      while (current !== null) {
        console.log(current.value)
        current = current.left
      }
      current = stack.pop()!
      stack.push(current)
      current = current.right
    }
  }
}

层序遍历

层序遍历很好理解，就是从上向下逐层遍历

层序遍历通常我们会借助队列来完成

  • 也是队列的一个经典应用场景

image-20230901104440111

class TreeNode<T> extends Node<T> {
  levelOrderTraverse() {
    // 1.如果没有根节点，那么不需要遍历
    if (!this.root) return
    // 2.创建队列结构
    const queue: TreeNode<T>[] = []
    queue.push(this.root)
    // 3.遍历队列中所有的节点（依次出队）
    while (queue.length) {
      // 3.1.访问节点的过程
      const current = queue.shift()!
      console.log(current.value)
      // 3.2.将左子节点放入队列
      if (current.left) {
        queue.push(current.left)
      }
      // 3.3.将右子节点放入到队列
      if (current.right) {
        queue.push(current.right)
      }
    }
  }
}

最值

在二叉搜索树中搜索最值是一件非常简单的事情，其实用眼睛就可以看出来了

在这里插入图片描述

class TreeNode<T> extends Node<T> {
  /** 获取最值操作：最大值 */
  getMaxValue(): T | null {
    let current = this.root
    while (current && current.right) {
      current = current.right
    }
    return current?.value ?? null
  }
  /** 获取最值操作：最小值 */
  getMinValue(): T | null {
    let current = this.root
    while (current && current.left) {
      current = current.left
    }
    return current?.value ?? null
  }
}

搜索特定的值

二叉搜索树不仅仅获取最值效率非常高，搜索特定的值效率也非常高

  • 注意：这里的实现返回 boolean 类型即可
class TreeNode<T> extends Node<T> {
  searchNoRecursion(value: T): boolean {
    let current = this.root
    while (current) {
      // 找到了节点
      if (current.value === value) return true
      if (current.value < value) {
        current = current.right
      } else {
        current = current.left
      }
    }
    return false
  }
  search(value: T): boolean {
    return this, this.searchNode(this.root, value)
  }
  searchNode(node: TreeNode<T> | null, value: T): boolean {
    // 1.如果节点为null，那么就直接退出递归
    if (node === null) return false
    // 2.判断node节点的value和传入的value的大小
    if (node.value > value) {
      return this.searchNode(node.left, value)
    } else if (node.value < value) {
      return this.searchNode(node.right, value)
    } else {
      return true
    }
  }
}

删除操作

二叉搜索树的删除有些复杂，我们一点点完成

删除节点要从查找到删除的节点开始，找到节点后，需要考虑三种情况：

  • 该节点是叶节点（没有子节点，比较简单）
  • 该节点有一个子节点（相对简单）
  • 该节点有两个子节点（情况复杂）

我们先从查找要删除的节点入手

  1. 先找到要删除的节点
  2. 找到要删除节点
    1. 删除叶子节点
    2. 删除只有一个子节点
    3. 删除有两个子节点的节点
class TreeNode<T> extends Node<T> {
  left: TreeNode<T> | null = null
  right: TreeNode<T> | null = null
  parent: TreeNode<T> | null = null
  get isLeft(): boolean {
    return !!(this.parent && this.parent.left === this)
  }
  get isRight(): boolean {
    return !!(this.parent && this.parent.right === this)
  }
}

class TreeNode<T> extends Node<T> {
  private searchNode(value: T): TreeNode<T> | null {
    let current = this.root
    let parent: TreeNode<T> | null = null
    while (current) {
      if (current.value === value) return current
      parent = current
      if (current.value < value) {
        current = current.right
      } else {
        current = current.left
      }
      if (current) current.parent = parent
    }
    return null
  }
}

情况一：没有子节点

  • 这种情况相对比较简单，我们需要检测 current 的 left 以及 right 是否都为 null
  • 都为 null 之后还要检测一个东西，就是是否 current 就是根，都为 null，并且为根，那么相当于清空了根，因为只有它
  • 否则就把父节点的 left 或者 right 字段设置为 null 即可

如果只有一个单独的根，直接删除即可

  • 如果是叶节点，那么处理方式如下
class TreeNode<T> extends Node<T> {
  remove(value: T): boolean {
    // 1.搜索当前是否有这个value
    const current = this.searchNode(value)
    if (!current) return false
    // 2.获取到三个东西：当前节点/父节点是否属于父节点的左子节点还是右子节点
    // 2.1.如果删除的是叶子节点
    if (current.left === null && current.right === null) {
      if (current === this.root) {
        // 根节点
        this.root = null
      } else if (current.isLeft) {
        // 父节点的左子节点
        current.parent!.left = null
      } else {
        current.parent!.right = null
      }
    }
    return true
  }
}

情况二：一个子节点

  • 这种情况也不是很难
  • 要删除的 current 节点，只有 2 个连接（如果有两个子节点，就是三个连接了），一个连接父节点，一个连接唯一的子节点
  • 需要从这三者之间：爷爷-自己-儿子，将自己（current）剪断，让爷爷直接连接儿子即可
  • 这个过程要求改变父节点的 left 或者 right，指向要删除节点的子节点
  • 当然，这个过程中还要考虑是否 current 就是根
class TreeNode<T> extends Node<T> {
	remove(value: T): boolean {
		if (current.right === null) {
      // 2.2.只有一个子节点，只有左子节点
      if (current === this.root) {
        this.root = current.left
      } else if (current.isLeft) {
        current.parent!.left = current.left
      } else {
        current.parent!.right = current.left
      }
    } else if (current.left === null) {
      // 2.3.只有一个子节点，只有右子节点
      if (current === this.root) {
        this.root = current.right
      } else if (current.isLeft) {
        current.parent!.left = current.right
      } else {
        current.parent!.right = current.right
      }
    }
    return true
  }
}

情况三：两个节点

image-20230904100428216

  • 情况一：删除 9 节点
    • 处理方式相对简单，将 8 位置替换到 9，或者将 10 位置替换到 9
    • 注意：这里是替换，也就是 8 位置替换到 9 时，7 指向 8，而 8 还需要指向 10
    • 找 8 或 10
  • 情况二：删除 7 节点
    • 一种方式是将 5 拿到 7 的位置，3 依然指向 5，但是 5 有一个 right，需要指向 9，依然是二叉搜索树
    • 另一种方式是在右侧找一个，找 8
    • 也就是将 8 替换到 7 的位置，8 的 left 指向 5，right 指向 9，依然是二叉搜索树
    • 找 5 或 8
  • 情况三：删除 15 节点，并且我希望也在右边找
    • 18 替换 15 的位置，20 的 left 指向 19，也是一个二叉搜索树
    • 找 14 或 18
class TreeNode<T> extends Node<T> {
  private getSuccessor(delNode: TreeNode<T>) {
    // 获取右子树
    let current = delNode.right
    let successor: TreeNode<T> | null = null
    while (current) {
      successor = current
      current = current.left
      if (current) {
        current.parent = successor
      }
    }
    // 拿到后继节点
    if (successor !== delNode.right) {
      successor!.parent!.left = successor!.right
      successor!.right = delNode.right
    }

    // 将删除节点的 left，赋值给后继节点的 left
    successor!.left = delNode.left
    return successor
  }
	remove(value: T): boolean {
    else {
      // 2.4.两个子节点
      const successor = this.getSuccessor(current)
      if (current === this.root) {
        this.root = successor
      } else if (current.isLeft) {
        current.parent!.left = successor
      } else {
        current.parent!.right = successor
      }
    }
    return true
  }
}

寻找规律

如果我们要 删除的节点有两个子节点，甚至子节点还有子节点，这种情况下我们需要 从下面的子节点中找到一个子节点，来替换当前的节点

但是找到这个节点有什么特征呢？应该是 current 节点下面所有节点中 最接近 current 节点 的

  • 要么比 current 节点小一点点，要么比 current 节点大一点点
  • 总结你最接近 current，你就可以用来替换 current 的位置

这个节点怎么找呢？

  • 比 current 小一点点的节点，一定是 current 左子树的最大值
  • 比 current 大一点点的节点，一定是 current 右子树的最小值

前驱和后继

  • 在二叉搜索树中，这两个特别的节点，有两个特别的名字
  • 比 current 小一点点的节点，称为 current 节点的 前驱
  • 比 current 大一点点的节点，称为 current 节点的 后继

也就是为了能够删除有两个子节点的 current，要么找到它的前驱，要么找到它的后继

class TreeNode<T> extends Node<T> {
	remove(value: T): boolean {
    // 1.搜索当前是否有这个value
    const current = this.searchNode(value)
    if (!current) return false
    // 2.获取到三个东西：当前节点/父节点是否属于父节点的左子节点还是右子节点
    let replaceNode: TreeNode<T> | null = null
    if (current.left === null && current.right === null) {
      // 2.1.如果删除的是叶子节点
      replaceNode = null
    } else if (current.right === null) {
      // 2.2.只有一个子节点，只有左子节点
      replaceNode = current.left
    } else if (current.left === null) {
      // 2.3.只有一个子节点，只有右子节点
      replaceNode = current.right
    } else {
      // 2.4.两个子节点
      const successor = this.getSuccessor(current)
      replaceNode = successor
    }
    if (current === this.root) {
      this.root = replaceNode
    } else if (current.isLeft) {
      current.parent!.left = replaceNode
    } else {
      current.parent!.right = replaceNode
    }
    return true
  }
}

删除操作非常复杂，一些程序员都尝试着避开删除操作

  • 他们的做法是在 Node 类中添加一个 boolean 字段，比如名称为 isDeleted
  • 要删除一个节点时，就将此字段设置为 true
  • 其他操作，比如 find() 在查找之前先判断这个节点是不是标记为删除
  • 这样相对比较简单，每次删除节点不会改变原有的树结构
  • 但是在二叉树的存储中，还保留这那些本已经被删除掉的节点

完整代码

import { btPrint } from 'hy-algokit'

class INode<T> {
  value: T
  constructor(value: T) {
    this.value = value
  }
}
class TreeNode<T> extends Node<T> {
  left: TreeNode<T> | null = null
  right: TreeNode<T> | null = null
  parent: TreeNode<T> | null = null
  get isLeft(): boolean {
    return !!(this.parent && this.parent.left === this)
  }
  get isRight(): boolean {
    return !!(this.parent && this.parent.right === this)
  }
}
class BSTree<T> {
  private root: TreeNode<T> | null = null
  print() {
    btPrint(this.root)
  }
  private searchNode(value: T): TreeNode<T> | null {
    let current = this.root
    let parent: TreeNode<T> | null = null
    while (current) {
      if (current.value === value) return current
      parent = current
      if (current.value < value) {
        current = current.right
      } else {
        current = current.left
      }
      if (current) current.parent = parent
    }
    return null
  }
  /** 插入数据的操作 */
  insert(value: T) {
    // 1.根据传入value创建Node(TreeNode)节点
    const newNode = new TreeNode(value)
    // 2.判断当前是否已经有了根节点
    if (!this.root) {
      // 当前树为空
      this.root = newNode
    } else {
      // 树中已经有其他值
      this.insertNode(this.root, newNode)
    }
  }
  private insertNode(node: TreeNode<T>, newNode: TreeNode<T>) {
    if (newNode.value < node.value) {
      // 去左边继续查找空白位置
      if (node.left === null) {
        node.left = newNode
      } else {
        this.insertNode(node.left, newNode)
      }
    } else {
      // 去右边继续查找空白位置
      if (node.right === null) {
        node.right = newNode
      } else {
        this.insertNode(node.right, newNode)
      }
    }
  }
  // 遍历的操作
  /** 先序遍历 */
  preOrderTraverse() {
    this.preOrderTraverseNode(this.root)
  }
  private preOrderTraverseNode(node: TreeNode<T> | null) {
    if (node) {
      console.log(node.value)
      this.preOrderTraverseNode(node.left)
      this.preOrderTraverseNode(node.right)
    }
  }
  /** 中序遍历 */
  inOrderTraverse() {
    this.inOrderTraverseNode(this.root)
  }
  private inOrderTraverseNode(node: TreeNode<T> | null) {
    if (node) {
      this.inOrderTraverseNode(node.left)
      console.log(node.value)
      this.inOrderTraverseNode(node.right)
    }
  }
  /** 后序遍历 */
  postOrderTraverse() {
    this.postOrderTraverseNode(this.root)
  }
  private postOrderTraverseNode(node: TreeNode<T> | null) {
    if (node) {
      this.postOrderTraverseNode(node.left)
      this.postOrderTraverseNode(node.right)
      console.log(node.value)
    }
  }
  /** 层序遍历 */
  levelOrderTraverse() {
    // 1.如果没有根节点，那么不需要遍历
    if (!this.root) return
    // 2.创建队列结构
    const queue: TreeNode<T>[] = []
    queue.push(this.root)
    // 3.遍历队列中所有的节点（依次出队）
    while (queue.length) {
      // 3.1访问节点的过程
      const current = queue.shift()!
      console.log(current.value)
      // 3.2将左子节点放入队列
      if (current.left) {
        queue.push(current.left)
      }
      // 3.3将右子节点放入到队列
      if (current.right) {
        queue.push(current.right)
      }
    }
  }
  /** 获取最值操作：最大值 */
  getMaxValue(): T | null {
    let current = this.root
    while (current && current.right) {
      current = current.right
    }
    return current?.value ?? null
  }
  /** 获取最值操作：最小值 */
  getMinValue(): T | null {
    let current = this.root
    while (current && current.left) {
      current = current.left
    }
    return current?.value ?? null
  }
  /** 搜索特定的值 */
  search(value: T): boolean {
    return !!this.searchNode(value)
  }
  searchNodeValue(node: TreeNode<T> | null, value: T): boolean {
    // 1.如果节点为null，那么就直接退出递归
    if (node === null) return false
    // 2.判断node节点的value和传入的value的大小
    if (node.value > value) {
      return this.searchNodeValue(node.left, value)
    } else if (node.value < value) {
      return this.searchNodeValue(node.right, value)
    } else {
      return true
    }
  }
  /** 删除操作 */
  private getSuccessor(delNode: TreeNode<T>) {
    // 获取右子树
    let current = delNode.right
    let successor: TreeNode<T> | null = null
    while (current) {
      successor = current
      current = current.left
      if (current) {
        current.parent = successor
      }
    }
    // 拿到后继节点
    if (successor !== delNode.right) {
      successor!.parent!.left = successor!.right
      successor!.right = delNode.right
    }

    // 将删除节点的 left，赋值给后继节点的 left
    successor!.left = delNode.left
    return successor
  }
  remove(value: T): boolean {
    // 1.搜索当前是否有这个value
    const current = this.searchNode(value)
    if (!current) return false
    // 2.获取到三个东西：当前节点/父节点是否属于父节点的左子节点还是右子节点
    let replaceNode: TreeNode<T> | null = null
    if (current.left === null && current.right === null) {
      // 2.1.如果删除的是叶子节点
      replaceNode = null
    } else if (current.right === null) {
      // 2.2.只有一个子节点，只有左子节点
      replaceNode = current.left
    } else if (current.left === null) {
      // 2.3.只有一个子节点，只有右子节点
      replaceNode = current.right
    } else {
      // 2.4.两个子节点
      const successor = this.getSuccessor(current)
      replaceNode = successor
    }
    if (current === this.root) {
      this.root = replaceNode
    } else if (current.isLeft) {
      current.parent!.left = replaceNode
    } else {
      current.parent!.right = replaceNode
    }
    return true
  }
}

平衡树

二叉搜索树缺陷

二叉搜索树作为数据存储的结构有重要的优势

  • 可以快速地找到给定关键字的数据项，并且可以快速地插入和删除数据项

但是，二叉搜索树有一个很麻烦的问题：

  • 如果插入的数据是有序的数据，比如下面的情况
  • 有一颗初始化为 9、8、12 的二叉树
  • 插入下面的数据：7、6、5、4、3

非平衡树

  • 比较好的二叉搜索树数据应该是 左右分布均匀 的
  • 但是插入 连续数据 后，分布的不均匀，称这种树为非平衡树
  • 对于一颗平衡二叉树来说，插入/查找等操作的效率是 O(logN)
  • 对于一颗非平衡二叉树，相当于编写了一个链表，查找效率变成了 O(N)

image-20230904171135081

平衡性

为了能以较快的时间 O(log N)来操作一棵树，我们需要保证树总是平衡的

  • 至少大部分是平衡的，那么时间复杂度也是接近 O(logN) 的
  • 也就是说树中 每个节点左边的子孙节点的个数，应该尽可能的等于 右边的子孙节点的个数

AVL 树

  • AVL 树是最早的一种平衡树，它有些办法保证树的平衡（每个节点存储了一个额外的数据）
  • 因为 AVL 树是平衡的，所以时间复杂度也是 O(logN)
  • 但是，每次插入/删除操作相对于红黑树效率都不高，所以整体效率不如红黑树

红黑树

  • 红黑树也通过一些特性来保持树的平衡
  • 因为是平衡树，所以时间复杂度也是 O(logN)
  • 另外插入/删除等操作，红黑树的性能要优于 AVL 树，所以现在平衡树的应用基本都是红黑树

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/972534.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

神策数据 CJO 系列丨解密 CJO：连接体验的下一个前沿趋势

神策数据 CJO 系列丨解密 CJO：连接体验的下一个前沿趋势

10 余年前&#xff0c;市场营销的焦点聚集在增长黑客如何利用 AARRR 模型&#xff08;获取 Acquisition、激活 Activation、留存 Retention、收入 Revenue、传播 Referral&#xff09;来推动并加速企业的生长发展。我们曾相信&#xff0c;在 AARRR 漏斗中&#xff0c;只要我们吸…
阅读更多...
宝塔面板定时监控和重启MySQL数据库(计划任务)

宝塔面板定时监控和重启MySQL数据库(计划任务)

往期教程 如果还有不了解宝塔面板怎么使用的小伙伴&#xff0c;可以看下我总结的系列教程&#xff0c;保证从新手变老鸟&#xff1a; 【建站流程科普】 个人和企业搭建网站基本流程及六个主要步骤常见的VPS主机运维面板汇总—网站运维面板云服务器&#xff0c;VPS&#xff0…
阅读更多...
76 # koa 上下文的实现原理

76 # koa 上下文的实现原理

上一节实现了 koa 基本逻辑实现以及属性的扩展&#xff0c;下面继续实现上下文的实现 ctx 跟 proto 的关系 ctx.__proto__.__proto__ protoMDN&#xff1a;defineGetter 备注&#xff1a; 此特性已弃用&#xff0c;建议使用对象初始化语法或 Object.defineProperty() API 来…
阅读更多...
《职场情绪稳定：内在的力量与策略》

《职场情绪稳定：内在的力量与策略》

近期发生的新闻热点&#xff0c;如大规模裁员、创业公司倒闭、公共卫生事件等&#xff0c;让公众更加关注稳定情绪和心理健康的问题。在职场中&#xff0c;我们常常遇到各种挑战和压力&#xff0c;如何保持稳定的情绪成了一个重要的话题。 首先&#xff0c;让我们分享一些工作中…
阅读更多...
RecyclerView的smooth scroller -- 诸多案例

RecyclerView的smooth scroller -- 诸多案例

作者&#xff1a;snwrking 最近碰到好几个使用LinearSmoothScroll(下方简称为LSS)的场景, 让我对这个类的了解更加进一步, 所以分享在这, 希望对有需要的同学有所帮助. 我个人不太喜欢太理论的东西, 所以整篇文章几乎全是我做过的案例, 也方便也有类似需求的同学对号入座地取用…
阅读更多...
【用unity实现100个游戏之8】用Unity制作一个炸弹人游戏

【用unity实现100个游戏之8】用Unity制作一个炸弹人游戏

文章目录 前言素材开始一、绘制地图二、玩家设置三、玩家移动四、玩家四方向动画运动切换 五、放置炸弹六、生成爆炸效果七、墙壁和可破坏障碍物的判断八、道具生成和效果九、玩家死亡十、简单的敌人AI十一、虚拟摇杆 待续源码完结 前言 我们将在这个视频中&#xff0c;学习如…
阅读更多...
Oracle 遍历变量游标

Oracle 遍历变量游标

背景 由于我们的数据库系统中的游标特别多&#xff0c;DBA让我们优化&#xff0c;减少游标的使用。 电脑系统&#xff1a;windows数据库&#xff1a;Oracle数据库图形化界面工具&#xff1a;Toad&#xff0c;DBeaver(我測試的時候用的)记录日期&#xff1a;2023-09-04 具体实…
阅读更多...
macbookpro怎么删除软件没有鼠标

macbookpro怎么删除软件没有鼠标

macbookpro怎么删除软件没有鼠标,macbookpro触摸板可以替代鼠标进行操作。左右键功能与鼠标相同&#xff0c;可用于执行删除操作。此外&#xff0c;还可以利用键盘上的Delete键来删除选中的文件。 删除软件方法 方法1、打开应用程序&#xff0c;键盘按住control&#xff0c;加点…
阅读更多...
解决微信小程序recycle-view使用百分比单位控制宽高时出现的内容溢出问题

解决微信小程序recycle-view使用百分比单位控制宽高时出现的内容溢出问题

recycle-view是微信小程序官方推出的一个经过优化的长列表组件&#xff0c;但是在使用百分比单位控制高宽时有个内容溢出问题&#xff0c;虽然它提供了height和width的参数可以设置宽高&#xff0c;但每次写列表都需要去js里获取宽高并设置是较为麻烦的&#xff0c;所以现在来着…
阅读更多...
Vue 3 基础（二）基础 1

Vue 3 基础（二）基础 1

API 参考 1、创建一个 Vue 应用 1.1 应用实例 每个 Vue 应用都是通过 createApp 函数创建一个新的 应用实例&#xff1a; import { createApp } from vueconst app createApp({/* 根组件选项 */ })1.2 根组件 我们传入 createApp 的对象实际上是一个组件&#xff0c;每个…
阅读更多...
【80天学习完《深入理解计算机系统》】第十三天 3.7 缓冲区溢出 attack lab

【80天学习完《深入理解计算机系统》】第十三天 3.7 缓冲区溢出 attack lab

3.7 缓冲区溢出 && attack lab
阅读更多...
uni-app 之 图片

uni-app 之 图片

uni-app 之 图片 获取图片 v-bind 动态绑定 image.png <template><view><view>--- 获取图片1 ---<image src"../../static/img/tabbar_home1.png"></image></view><view>--- 获取图片2 v-bind 动态绑定---<image v-bi…
阅读更多...
SolVES4.1学习1——安装与使用教程

SolVES4.1学习1——安装与使用教程

1、下载并安装 SolVES 4版本是QGIS插件&#xff0c;但实际使用过程中发现在最新版的QGIS安装该插件过程中&#xff0c;会报错或异常。因此需安装特定版本的软件。共需安装如下图软件及Java环境等。 根据官方文档安装好后&#xff0c;可以进行相关操作。 2、设置QGIS环境 QG…
阅读更多...
AutoSAR配置与实践（基础篇）3.7 BSW的WatchDog功能(下)

AutoSAR配置与实践（基础篇）3.7 BSW的WatchDog功能(下)

AutoSAR配置与实践（基础篇）3.7 BSW的WatchDog功能(下） BSW的WatchDog功能(下）一、WDG和其他模块交互BSW的WatchDog功能(下） ->返回总目录<- 一、WDG和其他模块交互 模块交互 看门狗模块由WdgM统一管理，这里围绕WdgM模块分析与其他模块交互。通过交互的说明，可以…
阅读更多...
css画箭头图标放标题前面，旋转，border的单个边框设置

css画箭头图标放标题前面，旋转，border的单个边框设置

CSS边框属性_css border dotted_小张biubiu的博客-CSDN博客 你还不知道css的旋转效果怎么实现&#xff1f;来这里看看吧_css旋转效果_我糖呢的博客-CSDN博客 .sub-title{position: relative;margin-left: 59px;& span{color: #1CDBFE;};& span::before{content: "…
阅读更多...
MyBatis-Plus深入 —— 条件构造器与插件管理

MyBatis-Plus深入 —— 条件构造器与插件管理

前言 在前面的文章中&#xff0c;荔枝梳理了一个MyBatis-Plus的基本使用、配置和通用Service接口&#xff0c;我们发现在MyBatis-Plus的辅助增强下我们不再需要通过配置xml文件中的sql语句来实现基本的sql操作了&#xff0c;不愧是最佳搭档&#xff01;在这篇文章中&#xff0c…
阅读更多...
ping: www.baidu.com: Name or service not known 写了DNS还是不行

ping: www.baidu.com: Name or service not known 写了DNS还是不行

环境描述&#xff1a;ESXI平台上&#xff0c;一台Centos7虚拟主机。 问题描述&#xff1a;平台上的其他的虚拟机可以正常ping通&#xff0c;就这台ping IP地址可以通&#xff0c;ping域名解析失败。 排查过程&#xff1a; 1、检查网卡配置文件和/etc/resolv.conf配置文件是否…
阅读更多...
【综述+3D】基于NeRF的三维视觉2023年度进展报告（截止2023.06.10）

【综述+3D】基于NeRF的三维视觉2023年度进展报告（截止2023.06.10）

论文&#xff1a;2003.Representing Scenes as Neural Radiance Fields for View Synthesis 官方网站&#xff1a;https://www.matthewtancik.com/nerf 突破性后续改进&#xff1a; Instant Neural Graphics Primitives with a Multiresolution Hash Encoding | 展示官网&#…
阅读更多...
K8S的介绍和架构

K8S的介绍和架构

仅供入门 K8S的介绍和架构 一. 什么是kubernetes二、Kubernetes架构和组件 2.1 核心组件 2.1.1 Kubernetes Master控制组件&#xff0c;调度管理整个系统&#xff08;集群&#xff09;&#xff0c;包含如下组件: a、Kubernetes API Serverb、Kubernetes Schedulerc、Kubernet…
阅读更多...
【前端】CSS-Grid网格布局

【前端】CSS-Grid网格布局

目录 一、grid布局是什么二、grid布局的属性三、容器属性1、display①、语句②、属性值 2、grid-template-columns属性、grid-template-rows属性①、定义②、属性值1&#xff09;、固定的列宽和行高2&#xff09;、repeat()函数3&#xff09;、auto-fill关键字4&#xff09;、f…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023