瑞_数据结构与算法_红黑树

文章目录

    • 1 什么是红黑树
      • 1.1 红黑树的背景
      • 1.2 红黑树的特性 ★★★
    • 2 红黑树的Java实现
      • 2.1 红黑树颜色枚举类Color
      • 2.2 红黑树节点类Node
        • 2.2.1 实现判断是否是左孩子方法isLeftChild()
        • 2.2.2 实现查找叔叔节点方法uncle()
        • 2.2.3 实现查找兄弟节点方法sibling()
      • 2.3 红黑树类RedBlackTree
        • 2.3.1 实现判断是否为红色节点方法isRed(Node node)
        • 2.3.2 实现判断是否为黑色节点方法isBlack(Node node)
        • 2.3.3 实现右旋方法rightRotate(Node pink)
        • 2.3.4 实现左旋方法leftRotate(Node pink)
        • 2.3.5 实现新增或更新方法put(int key, Object value) ★
        • 2.3.6 实现删除方法remove(int key) ★
    • 3 红黑树Java实现代码完整版（复制粘贴用）
    • 二叉搜索树小结

🙊前言：本文章为瑞_系列专栏之《数据结构与算法》的红黑树篇。由于博主是从B站黑马程序员的《数据结构与算法》学习到的相关知识，所以本系列专栏主要针对该课程进行笔记总结和拓展，文中的部分原理及图解也是来源于黑马提供的资料。本文仅供大家交流、学习及研究使用，禁止用于商业用途，违者必究！

在这里插入图片描述

1 什么是红黑树

1.1 红黑树的背景

  红黑树是一种自平衡二叉查找树，最早由一位名叫Rudolf Bayer的德国计算机科学家于1972年发明。然而，最初的树形结构不是现在的红黑树，而是一种称为B树的结构，它是一种多叉树，可用于在磁盘上存储大量数据。

  在1980年代早期，计算机科学家Leonard Adleman和Daniel Sleator推广了红黑树，并证明了它的自平衡性和高效性。从那时起，红黑树成为了最流行的自平衡二叉查找树之一，并被广泛应用于许多领域，如编译器、操作系统、数据库等。

  红黑树的名字来源于红色节点和黑色节点的交替出现，它们的颜色是用来维护树的平衡性的关键。它们的颜色具有特殊的意义，黑色节点代表普通节点，而红色节点代表一个新添加的节点，它们必须满足一些特定的规则才能维持树的平衡性。

  红黑树也是一种自平衡的二叉搜索树，较之 AVL树，插入和删除时旋转次数更少。所以红黑树和AVL的区别主要在于判断平衡的依据不同。无论是AVL树还是红黑树，都是为了确保树的平衡性，从而提高搜索、插入和删除操作的效率。
  关于AVL树的相关知识，可以参考《瑞_数据结构与算法_AVL树》

1.2 红黑树的特性 ★★★

  1. 所有节点都有两种颜色：红🔴、黑⚫️
  2. 所有 null 视为黑色⚫️
  3. 红色🔴节点不能相邻
  4. 根节点是黑色⚫️
  5. 从根到任意一个叶子节点，路径中的黑色⚫️节点数一样（黑色完美平衡）

  第3条、第5条很重要，是判断平衡的主要依据。且当一个叶子节点没有兄弟的时候，就需要考虑null值（null 视为黑色）。

  判断1：❌如下二叉树不是平衡的红黑树❌，违反了第3条（红色🔴节点不能相邻）
在这里插入图片描述

  判断2：❌如下二叉树不是平衡的红黑树❌，违反了第5条，根节点6到7和9路径中的黑色节点数为3，而根节点6到1和3路径中的黑色节点数为2，所以右边重，左边轻
在这里插入图片描述

  判断3：✅如下二叉树是一颗平衡的红黑树✅5个特性均满足
在这里插入图片描述

  判断4：❌如下二叉树不是平衡的红黑树❌，注意区别判断3。其实当一个叶子节点没有兄弟的时候，就需要考虑null值（null 视为黑色）
在这里插入图片描述
  上图加上null值（视为黑色）后，如下所示，根节点6到节点1的左右孩子（null）的路径中的黑色节点有3个，而根节点6到节点2的右孩子路径中的黑色节点只有2个，所以违反了特性5（从根到任意一个叶子节点，路径中的黑色⚫️节点数一样）

在这里插入图片描述

  瑞：所以在判断是否为红黑树的时候，当一个叶子节点没有兄弟的时候，就需要考虑null值（null 视为黑色），得出以下经验

  1️⃣叶子节点如果为红色🔴，是可以单独存在的（可以没有兄弟），但是如果叶子节点为黑色⚫️没有兄弟的，就是不平衡的。
:  two:红色🔴节点的孩子肯定是黑色⚫️，而且如果红色节点有孩子一定是两个黑色节点，因为如果只有一个黑色节点孩子意味着违反了特性5



2 红黑树的Java实现


1️⃣内部颜色枚举类Color中含有：

  • RED
  • BLACK

2️⃣➖1️⃣内部节点类Node中含有属性：

  • 索引
  • 存储值
  • 左孩子
  • 右孩子
  • 父节点
  • 颜色Color枚举类

2️⃣➖2️⃣内部节点类Node中含有内部工具方法：

  • 判断是否是左孩子isLeftChild()
  • 查找叔叔节点uncle()
  • 查找兄弟节点sibling()

3️⃣➖1️⃣红黑树类RedBlackTree中含有属性：

  • 根节点（Node）

3️⃣➖2️⃣红黑树类RedBlackTree中含有方法：

  • 判断是否为红色节点isRed(Node node)
  • 判断是否为黑色节点isBlack(Node node)
  • 右旋rightRotate(Node pink)
  • 左旋leftRotate(Node pink)
  • 新增或更新put(int key, Object value)
  • 修复新增中不平衡的情况fixRedRed(Node x)
  • 删除remove(int key)
  • 判断节点是否存在contains(int key)
  • 查找删除节点find(int key)
  • 查找剩余节点findReplaced(Node deleted)
  • 处理双黑fixDoubleBlack(Node x)

2.1 红黑树颜色枚举类Color

    enum Color {RED, BLACK;}

2.2 红黑树节点类Node

    static class Node {/*** 索引*/int key;/*** 存储值*/Object value;/*** 左孩子*/Node left;/*** 右孩子*/Node right;/*** 父节点*/Node parent;/*** 颜色（新节点初始值默认红色）*/Color color = Color.RED;public Node(int key, Object value) {this.key = key;this.value = value;}public Node(int key) {this.key = key;}public Node(int key, Color color) {this.key = key;this.color = color;}public Node(int key, Color color, Node left, Node right) {this.key = key;this.color = color;this.left = left;this.right = right;if (left != null) {left.parent = this;}if (right != null) {right.parent = this;}}// 判断是否是左孩子boolean isLeftChild() {return parent != null && parent.left == this;}// 查找叔叔节点（父节点的兄弟节点）Node uncle() {// 如果父节点为null或者爷爷节点为null，是没有叔叔节点的if (parent == null || parent.parent == null) {return null;}// 如果父亲是爷爷的左孩子，叔叔则是爷爷的右孩子if (parent.isLeftChild()) {return parent.parent.right;} else {// 如果父亲是爷爷的右孩子，叔叔则是爷爷的左孩子return parent.parent.left;}}// 查找兄弟节点Node sibling() {// 如果父亲为null，一定没有兄弟节点if (parent == null) {return null;}// 如果当前节点是父亲的左孩子，兄弟节点是父亲的右孩子if (this.isLeftChild()) {return parent.right;} else {// 如果当前节点是父亲的右孩子，兄弟节点是父亲的左孩子return parent.left;}}}
2.2.1 实现判断是否是左孩子方法isLeftChild()
        // 判断是否是左孩子boolean isLeftChild() {return parent != null && parent.left == this;}
2.2.2 实现查找叔叔节点方法uncle()

  叔叔节点即父节点的兄弟节点

        // 查找叔叔节点（父节点的兄弟节点）Node uncle() {// 如果父节点为null或者爷爷节点为null，是没有叔叔节点的if (parent == null || parent.parent == null) {return null;}// 如果父亲是爷爷的左孩子，叔叔则是爷爷的右孩子if (parent.isLeftChild()) {return parent.parent.right;} else {// 如果父亲是爷爷的右孩子，叔叔则是爷爷的左孩子return parent.parent.left;}}
2.2.3 实现查找兄弟节点方法sibling()
        // 查找兄弟节点Node sibling() {// 如果父亲为null，一定没有兄弟节点if (parent == null) {return null;}// 如果当前节点是父亲的左孩子，兄弟节点是父亲的右孩子if (this.isLeftChild()) {return parent.right;} else {// 如果当前节点是父亲的右孩子，兄弟节点是父亲的左孩子return parent.left;}}

2.3 红黑树类RedBlackTree

2.3.1 实现判断是否为红色节点方法isRed(Node node)
    // 判断是否为红色节点boolean isRed(Node node) {return node != null && node.color == Color.RED;}
2.3.2 实现判断是否为黑色节点方法isBlack(Node node)
    // 判断是否为黑色节点boolean isBlack(Node node) {return node == null || node.color == Color.BLACK;}
2.3.3 实现右旋方法rightRotate(Node pink)

  类似AVL树的右旋方法，思想基本一致，但是要多处理父节点属性，同时意味着旋转后的新根的父子关系需要处理。关于AVL树的右旋，可以参考《瑞_数据结构与算法_AVL树》

  假设一颗红黑树向右旋转前，如下图所示：
在这里插入图片描述

  • 粉红色节点，旧根（失衡节点）
  • 黄色节点，旧根的左孩子，将来作为新根，旧根是它右孩子
  • 绿色节点，新根的右孩子，将来要换爹作为旧根的左孩子

  右旋后，如下图所示：

在这里插入图片描述

  实现代码如下：

    // 右旋 1. parent 的处理 2. 旋转后新根的父子关系private void rightRotate(Node pink) {Node parent = pink.parent;Node yellow = pink.left;Node green = yellow.right;if (green != null) {green.parent = pink;}yellow.right = pink;yellow.parent = parent;pink.left = green;pink.parent = yellow;if (parent == null) {root = yellow;} else if (parent.left == pink) {parent.left = yellow;} else {parent.right = yellow;}}
2.3.4 实现左旋方法leftRotate(Node pink)

  与右旋方法思想一样，代码如下：

    // 左旋private void leftRotate(Node pink) {Node parent = pink.parent;Node yellow = pink.right;Node green = yellow.left;if (green != null) {green.parent = pink;}yellow.left = pink;yellow.parent = parent;pink.right = green;pink.parent = yellow;if (parent == null) {root = yellow;} else if (parent.left == pink) {parent.left = yellow;} else {parent.right = yellow;}}
2.3.5 实现新增或更新方法put(int key, Object value) ★

  与AVL树的put方法的思想类似，但要多考虑红红不平衡的情况，需要进行调整（红黑树特性3 红色🔴节点不能相邻）

瑞：红黑树恢复平衡一般通过两种情况：变色、旋转。关于失衡的四种情况LL、LR、RL、RR，以及解决失衡的左旋（RR）、右旋（LL）、先左旋再右旋（LR）、先右旋再左旋（RL）可以参考《瑞_数据结构与算法_AVL树》（建议先学会AVL树再学习红黑树）

  插入情况分为4种，具体如下：

  • 默认插入节点均视为红色🔴

  1️⃣ 插入节点为根节点，将根节点变黑⚫️

  2️⃣ 插入节点的父亲若为黑色⚫️，树的红黑性质不变，无需调整

  • 插入节点的父亲为红色🔴，触发红红相邻，违反特性3

  3️⃣ 叔叔为红色🔴

    3️⃣➖1️⃣ 父亲变为黑色⚫️，为了保证黑色平衡，连带的叔叔也变为黑色⚫️

    3️⃣➖2️⃣祖父如果是黑色不变，会造成这颗子树黑色过多，因此祖父节点变为红色🔴

    3️⃣➖3️⃣ 祖父如果变成红色，可能会接着触发红红相邻，因此对将祖父进行递归调整

  4️⃣ 叔叔为黑色⚫️

    4️⃣➖1️⃣ 父亲为左孩子，插入节点也是左孩子，此时即 LL 不平衡

      4️⃣➖1️⃣➖1️⃣ 让父亲变黑⚫️，为了保证这颗子树黑色不变，将祖父变成红🔴，但叔叔子树少了一个黑色

      4️⃣➖1️⃣➖2️⃣ 祖父右旋，补齐一个黑色给叔叔，父亲旋转上去取代祖父，由于它是黑色，不会再次触发红红相邻

    4️⃣➖2️⃣ 父亲为左孩子，插入节点是右孩子，此时即 LR 不平衡

      4️⃣➖2️⃣➖1️⃣ 父亲左旋，变成 LL 情况，按 1. 来后续处理

    4️⃣➖3️⃣ 父亲为右孩子，插入节点也是右孩子，此时即 RR 不平衡

      4️⃣➖3️⃣➖1️⃣ 让父亲变黑⚫️，为了保证这颗子树黑色不变，将祖父变成红🔴，但叔叔子树少了一个黑色

      4️⃣➖3️⃣➖1️⃣ 祖父左旋，补齐一个黑色给叔叔，父亲旋转上去取代祖父，由于它是黑色，不会再次触发红红相邻

    4️⃣➖4️⃣ 父亲为右孩子，插入节点是左孩子，此时即 RL 不平衡

      4️⃣➖4️⃣➖1️⃣ 父亲右旋，变成 RR 情况，按 3. 来后续处理

  实现代码如下：

    /*** 新增或更新* <br>* 正常增、遇到红红不平衡进行调整** @param key   键* @param value 值*/public void put(int key, Object value) {Node p = root;Node parent = null;while (p != null) {parent = p;if (key < p.key) {p = p.left;} else if (p.key < key) {p = p.right;} else {p.value = value; // 更新return;}}Node inserted = new Node(key, value);if (parent == null) {root = inserted;} else if (key < parent.key) {parent.left = inserted;inserted.parent = parent;} else {parent.right = inserted;inserted.parent = parent;}fixRedRed(inserted);}/*** 修复新增中不平衡的情况** @param x 新增节点**/void fixRedRed(Node x) {// case 1 插入节点是根节点，变黑即可if (x == root) {x.color = Color.BLACK;return;}// case 2 插入节点父亲是黑色，无需调整if (isBlack(x.parent)) {return;}/* case 3 当红红相邻，叔叔为红时需要将父亲、叔叔变黑、祖父变红，然后对祖父做递归处理*/Node parent = x.parent;Node uncle = x.uncle();Node grandparent = parent.parent;if (isRed(uncle)) {parent.color = Color.BLACK;uncle.color = Color.BLACK;grandparent.color = Color.RED;fixRedRed(grandparent);return;}// case 4 当红红相邻，叔叔为黑时if (parent.isLeftChild() && x.isLeftChild()) { // LLparent.color = Color.BLACK;grandparent.color = Color.RED;rightRotate(grandparent);} else if (parent.isLeftChild()) { // LRleftRotate(parent);x.color = Color.BLACK;grandparent.color = Color.RED;rightRotate(grandparent);} else if (!x.isLeftChild()) { // RRparent.color = Color.BLACK;grandparent.color = Color.RED;leftRotate(grandparent);} else { // RLrightRotate(parent);x.color = Color.BLACK;grandparent.color = Color.RED;leftRotate(grandparent);}}
2.3.6 实现删除方法remove(int key) ★

  与AVL树的remove方法的思想类似，但要多考虑黑黑不平衡的情况，需要进行调整

瑞：红黑树恢复平衡一般通过两种情况：变色、旋转。关于失衡的四种情况LL、LR、RL、RR，以及解决失衡的左旋（RR）、右旋（LL）、先左旋再右旋（LR）、先右旋再左旋（RL）可以参考《瑞_数据结构与算法_AVL树》（建议先学会AVL树再学习红黑树）

  删除情况（case）分为6种，具体如下：

  0️⃣ 如果删除节点有两个孩子，化简成只有一个孩子或没有孩子

    0️⃣➖1️⃣ 交换删除节点和后继节点的 key，value，递归删除后继节点，直到该节点没有孩子或只剩一个孩子

瑞：使用这个技巧，就可以将两个孩子的问题转换为一个孩子或没有孩子的情况

  • 如果删除节点没有孩子或只剩一个孩子

  1️⃣ 删的是根节点

    1️⃣➖1️⃣ 删完了，直接将 root = null

    1️⃣➖2️⃣ 用剩余节点替换了根节点的 key，value，根节点孩子 = null，颜色保持黑色⚫️不变

  • 删黑色会失衡，删红色不会失衡，但删黑色有一种简单情况

  2️⃣ 删的是黑⚫️，剩下的是红🔴，剩下这个红节点变黑⚫️

瑞：只要是删除黑色节点，都会失衡。解决方法：兄弟变为红色，父亲变为黑色。中间的红色节点的删除不用考虑失衡，因为删中间的红色节点最终都会转化为删黑色节点，因为红色节点如果有孩子，就只能有两个黑色节点孩子（一个黑孩子意味着违反特性5），就会转化为情况0️⃣，变为一个孩子或者没有孩子的情况，就会和后继进行交换，此时其实删除的就是黑色节点。

  • 删除节点和剩下节点都是黑⚫️，触发双黑，双黑意思是，少了一个黑（整个路径上缺少一个黑导致失衡）

  3️⃣ 被调整节点的兄弟为红🔴，此时两个侄子定为黑 ⚫️

    3️⃣➖1️⃣ 删除节点是左孩子，父亲左旋

    3️⃣➖2️⃣ 删除节点是右孩子，父亲右旋

    3️⃣➖3️⃣ 父亲和兄弟要变色，保证旋转后颜色平衡

    3️⃣➖4️⃣ 旋转的目的是让黑侄子变为删除节点的黑兄弟，对删除节点再次递归，进入 case 4️⃣ 或 case 5️⃣

case3️⃣相当于是一种过渡情况，并不能通过调整自己恢复平衡，需要将case3️⃣转换为case4️⃣或case5️⃣，进一步调整

瑞：由于调整，全部黑色节点的红黑树是可能出现的情况，通过变色可以解决情况4

  4️⃣ 被调整节点的兄弟为黑⚫️，两个侄子都为黑 ⚫️

    4️⃣➖1️⃣ 将兄弟变红🔴，目的是将删除节点和兄弟那边的黑色高度同时减少 1

    4️⃣➖2️⃣ 如果父亲是红🔴，则需将父亲变为黑，避免红红，此时路径黑节点数目不变

    4️⃣➖3️⃣ 如果父亲是黑⚫️，说明这条路径还是少黑，再次让父节点触发双黑

情况5通过变色解决不了平衡问题，还需要通过旋转才能平衡

  5️⃣ 被调整节点的兄弟为黑⚫️，至少一个红🔴侄子

    5️⃣➖1️⃣ 如果兄弟是左孩子，左侄子是红🔴，LL 不平衡

      5️⃣➖1️⃣➖1️⃣ 将来删除节点这边少个黑，所以最后旋转过来的父亲需要变成黑⚫️，平衡起见，左侄子也是黑⚫️

      5️⃣➖1️⃣➖2️⃣ 原来兄弟要成为父亲，需要保留父亲颜色

    5️⃣➖2️⃣ 如果兄弟是左孩子，右侄子是红🔴，LR 不平衡

      5️⃣➖2️⃣➖1️⃣ 将来删除节点这边少个黑，所以最后旋转过来的父亲需要变成黑⚫️

      5️⃣➖2️⃣➖2️⃣ 右侄子会取代原来父亲，因此它保留父亲颜色

      5️⃣➖2️⃣➖3️⃣ 兄弟已经是黑了⚫️，无需改变

    5️⃣➖3️⃣ 如果兄弟是右孩子，右侄子是红🔴，RR 不平衡

      5️⃣➖3️⃣➖1️⃣ 将来删除节点这边少个黑，所以最后旋转过来的父亲需要变成黑⚫️，平衡起见，右侄子也是黑⚫️

      5️⃣➖3️⃣➖1️⃣ 原来兄弟要成为父亲，需要保留父亲颜色

    5️⃣➖4️⃣ 如果兄弟是右孩子，左侄子是红🔴，RL 不平衡

      5️⃣➖4️⃣➖1️⃣ 将来删除节点这边少个黑，所以最后旋转过来的父亲需要变成黑⚫️

      5️⃣➖4️⃣➖2️⃣ 左侄子会取代原来父亲，因此它保留父亲颜色

      5️⃣➖4️⃣➖3️⃣ 兄弟已经是黑了⚫️，无需改变

  实现代码如下：

/*** 删除* <br>* 正常删、会用到李代桃僵技巧、遇到黑黑不平衡进行调整** @param key 键*/public void remove(int key) {Node deleted = find(key);if (deleted == null) {return;}doRemove(deleted);}// 查找删除节点private Node find(int key) {Node p = root;while (p != null) {if (key < p.key) {p = p.left;} else if (p.key < key) {p = p.right;} else {return p;}}return null;}// 判断节点是否存在public boolean contains(int key) {return find(key) != null;}// 查找剩余节点private Node findReplaced(Node deleted) {if (deleted.left == null && deleted.right == null) {return null;}if (deleted.left == null) {return deleted.right;}if (deleted.right == null) {return deleted.left;}Node s = deleted.right;while (s.left != null) {s = s.left;}return s;}// 处理双黑 (case3、case4、case5)private void fixDoubleBlack(Node x) {if (x == root) {return;}Node parent = x.parent;Node sibling = x.sibling();// case 3 兄弟节点是红色if (isRed(sibling)) {if (x.isLeftChild()) {leftRotate(parent);} else {rightRotate(parent);}parent.color = Color.RED;sibling.color = Color.BLACK;fixDoubleBlack(x);return;}if (sibling != null) {// case 4 兄弟是黑色, 两个侄子也是黑色if (isBlack(sibling.left) && isBlack(sibling.right)) {sibling.color = Color.RED;if (isRed(parent)) {parent.color = Color.BLACK;} else {fixDoubleBlack(parent);}}// case 5 兄弟是黑色, 侄子有红色else {// LLif (sibling.isLeftChild() && isRed(sibling.left)) {rightRotate(parent);sibling.left.color = Color.BLACK;sibling.color = parent.color;}// LRelse if (sibling.isLeftChild() && isRed(sibling.right)) {sibling.right.color = parent.color;leftRotate(sibling);rightRotate(parent);}// RLelse if (!sibling.isLeftChild() && isRed(sibling.left)) {sibling.left.color = parent.color;rightRotate(sibling);leftRotate(parent);}// RRelse {leftRotate(parent);sibling.right.color = Color.BLACK;sibling.color = parent.color;}parent.color = Color.BLACK;}} else {// @TODO 实际也不会出现，触发双黑后，兄弟节点不会为 nullfixDoubleBlack(parent);}}// 删除递归private void doRemove(Node deleted) {Node replaced = findReplaced(deleted);Node parent = deleted.parent;// 没有孩子if (replaced == null) {// case 1 删除的是根节点if (deleted == root) {root = null;} else {if (isBlack(deleted)) {// 复杂调整fixDoubleBlack(deleted);} else {// 红色叶子, 无需任何处理}if (deleted.isLeftChild()) {parent.left = null;} else {parent.right = null;}deleted.parent = null;}return;}// 有一个孩子if (deleted.left == null || deleted.right == null) {// case 1 删除的是根节点if (deleted == root) {root.key = replaced.key;root.value = replaced.value;root.left = root.right = null;} else {if (deleted.isLeftChild()) {parent.left = replaced;} else {parent.right = replaced;}replaced.parent = parent;deleted.left = deleted.right = deleted.parent = null; // help gcif (isBlack(deleted) && isBlack(replaced)) {// 复杂处理 @TODO 实际不会有这种情况 因为只有一个孩子时 被删除节点是黑色 那么剩余节点只能是红色不会触发双黑fixDoubleBlack(replaced);} else {// case 2 删除是黑，剩下是红replaced.color = Color.BLACK;}}return;}// case 0 有两个孩子 => 有一个孩子 或 没有孩子int t = deleted.key;deleted.key = replaced.key;replaced.key = t;Object v = deleted.value;deleted.value = replaced.value;replaced.value = v;doRemove(replaced);}

3 红黑树Java实现代码完整版（复制粘贴用）

/*** <h3>红黑树</h3>*/
public class RedBlackTree {enum Color {RED, BLACK;}/*** 根节点*/Node root;static class Node {/*** 索引*/int key;/*** 存储值*/Object value;/*** 左孩子*/Node left;/*** 右孩子*/Node right;/*** 父节点*/Node parent;/*** 颜色（新节点初始值默认红色）*/Color color = Color.RED;public Node(int key, Object value) {this.key = key;this.value = value;}public Node(int key) {this.key = key;}public Node(int key, Color color) {this.key = key;this.color = color;}public Node(int key, Color color, Node left, Node right) {this.key = key;this.color = color;this.left = left;this.right = right;if (left != null) {left.parent = this;}if (right != null) {right.parent = this;}}// 判断是否是左孩子boolean isLeftChild() {return parent != null && parent.left == this;}// 查找叔叔节点（父节点的兄弟节点）Node uncle() {// 如果父节点为null或者爷爷节点为null，是没有叔叔节点的if (parent == null || parent.parent == null) {return null;}// 如果父亲是爷爷的左孩子，叔叔则是爷爷的右孩子if (parent.isLeftChild()) {return parent.parent.right;} else {// 如果父亲是爷爷的右孩子，叔叔则是爷爷的左孩子return parent.parent.left;}}// 查找兄弟节点Node sibling() {// 如果父亲为null，一定没有兄弟节点if (parent == null) {return null;}// 如果当前节点是父亲的左孩子，兄弟节点是父亲的右孩子if (this.isLeftChild()) {return parent.right;} else {// 如果当前节点是父亲的右孩子，兄弟节点是父亲的左孩子return parent.left;}}}// 判断是否为红色节点boolean isRed(Node node) {return node != null && node.color == Color.RED;}// 判断是否为黑色节点boolean isBlack(Node node) {
//        return !isRed(node);return node == null || node.color == Color.BLACK;}// 右旋 1. parent 的处理 2. 旋转后新根的父子关系private void rightRotate(Node pink) {Node parent = pink.parent;Node yellow = pink.left;Node green = yellow.right;if (green != null) {green.parent = pink;}yellow.right = pink;yellow.parent = parent;pink.left = green;pink.parent = yellow;if (parent == null) {root = yellow;} else if (parent.left == pink) {parent.left = yellow;} else {parent.right = yellow;}}// 左旋private void leftRotate(Node pink) {Node parent = pink.parent;Node yellow = pink.right;Node green = yellow.left;if (green != null) {green.parent = pink;}yellow.left = pink;yellow.parent = parent;pink.right = green;pink.parent = yellow;if (parent == null) {root = yellow;} else if (parent.left == pink) {parent.left = yellow;} else {parent.right = yellow;}}/*** 新增或更新* <br>* 正常增、遇到红红不平衡进行调整** @param key   键* @param value 值*/public void put(int key, Object value) {Node p = root;Node parent = null;while (p != null) {parent = p;if (key < p.key) {p = p.left;} else if (p.key < key) {p = p.right;} else {p.value = value; // 更新return;}}Node inserted = new Node(key, value);if (parent == null) {root = inserted;} else if (key < parent.key) {parent.left = inserted;inserted.parent = parent;} else {parent.right = inserted;inserted.parent = parent;}fixRedRed(inserted);}/*** 修复新增中不平衡的情况** @param x 新增节点**/void fixRedRed(Node x) {// case 1 插入节点是根节点，变黑即可if (x == root) {x.color = Color.BLACK;return;}// case 2 插入节点父亲是黑色，无需调整if (isBlack(x.parent)) {return;}/* case 3 当红红相邻，叔叔为红时需要将父亲、叔叔变黑、祖父变红，然后对祖父做递归处理*/Node parent = x.parent;Node uncle = x.uncle();Node grandparent = parent.parent;if (isRed(uncle)) {parent.color = Color.BLACK;uncle.color = Color.BLACK;grandparent.color = Color.RED;fixRedRed(grandparent);return;}// case 4 当红红相邻，叔叔为黑时if (parent.isLeftChild() && x.isLeftChild()) { // LLparent.color = Color.BLACK;grandparent.color = Color.RED;rightRotate(grandparent);} else if (parent.isLeftChild()) { // LRleftRotate(parent);x.color = Color.BLACK;grandparent.color = Color.RED;rightRotate(grandparent);} else if (!x.isLeftChild()) { // RRparent.color = Color.BLACK;grandparent.color = Color.RED;leftRotate(grandparent);} else { // RLrightRotate(parent);x.color = Color.BLACK;grandparent.color = Color.RED;leftRotate(grandparent);}}/*** 删除* <br>* 正常删、会用到李代桃僵技巧、遇到黑黑不平衡进行调整** @param key 键*/public void remove(int key) {Node deleted = find(key);if (deleted == null) {return;}doRemove(deleted);}// 查找删除节点private Node find(int key) {Node p = root;while (p != null) {if (key < p.key) {p = p.left;} else if (p.key < key) {p = p.right;} else {return p;}}return null;}// 判断节点是否存在public boolean contains(int key) {return find(key) != null;}// 查找剩余节点private Node findReplaced(Node deleted) {if (deleted.left == null && deleted.right == null) {return null;}if (deleted.left == null) {return deleted.right;}if (deleted.right == null) {return deleted.left;}Node s = deleted.right;while (s.left != null) {s = s.left;}return s;}// 处理双黑 (case3、case4、case5)private void fixDoubleBlack(Node x) {if (x == root) {return;}Node parent = x.parent;Node sibling = x.sibling();// case 3 兄弟节点是红色if (isRed(sibling)) {if (x.isLeftChild()) {leftRotate(parent);} else {rightRotate(parent);}parent.color = Color.RED;sibling.color = Color.BLACK;fixDoubleBlack(x);return;}if (sibling != null) {// case 4 兄弟是黑色, 两个侄子也是黑色if (isBlack(sibling.left) && isBlack(sibling.right)) {sibling.color = Color.RED;if (isRed(parent)) {parent.color = Color.BLACK;} else {fixDoubleBlack(parent);}}// case 5 兄弟是黑色, 侄子有红色else {// LLif (sibling.isLeftChild() && isRed(sibling.left)) {rightRotate(parent);sibling.left.color = Color.BLACK;sibling.color = parent.color;}// LRelse if (sibling.isLeftChild() && isRed(sibling.right)) {sibling.right.color = parent.color;leftRotate(sibling);rightRotate(parent);}// RLelse if (!sibling.isLeftChild() && isRed(sibling.left)) {sibling.left.color = parent.color;rightRotate(sibling);leftRotate(parent);}// RRelse {leftRotate(parent);sibling.right.color = Color.BLACK;sibling.color = parent.color;}parent.color = Color.BLACK;}} else {// @TODO 实际也不会出现，触发双黑后，兄弟节点不会为 nullfixDoubleBlack(parent);}}// 删除递归private void doRemove(Node deleted) {Node replaced = findReplaced(deleted);Node parent = deleted.parent;// 没有孩子if (replaced == null) {// case 1 删除的是根节点if (deleted == root) {root = null;} else {if (isBlack(deleted)) {// 复杂调整fixDoubleBlack(deleted);} else {// 红色叶子, 无需任何处理}if (deleted.isLeftChild()) {parent.left = null;} else {parent.right = null;}deleted.parent = null;}return;}// 有一个孩子if (deleted.left == null || deleted.right == null) {// case 1 删除的是根节点if (deleted == root) {root.key = replaced.key;root.value = replaced.value;root.left = root.right = null;} else {if (deleted.isLeftChild()) {parent.left = replaced;} else {parent.right = replaced;}replaced.parent = parent;deleted.left = deleted.right = deleted.parent = null; // help gcif (isBlack(deleted) && isBlack(replaced)) {// 复杂处理 @TODO 实际不会有这种情况 因为只有一个孩子时 被删除节点是黑色 那么剩余节点只能是红色不会触发双黑fixDoubleBlack(replaced);} else {// case 2 删除是黑，剩下是红replaced.color = Color.BLACK;}}return;}// case 0 有两个孩子 => 有一个孩子 或 没有孩子int t = deleted.key;deleted.key = replaced.key;replaced.key = t;Object v = deleted.value;deleted.value = replaced.value;replaced.value = v;doRemove(replaced);}
}

二叉搜索树小结

二叉搜索树可以参考《瑞_数据结构与算法_二叉搜索树》
AVL树可以参考《瑞_数据结构与算法_AVL树》

  二叉搜索树对比如下：

维度普通二叉搜索树AVL树红黑树
查询平均O(logn)，最坏O(n)O(logn)O(logn)
插入平均O(logn)，最坏O(n)O(logn)O(logn)
删除平均O(logn)，最坏O(n)O(logn)O(logn)
平衡性不平衡严格平衡近似平衡
结构二叉树自平衡的二叉树具有红黑性质的自平衡二叉树
查找效率低高高
插入删除效率低中高

  普通二叉搜索树插入、删除、查询的时间复杂度与树的高度相关，因此在最坏情况下，时间复杂度为O(n)，而且容易退化成链表，查找效率低。

  AVL树是一种高度平衡的二叉搜索树，其左右子树的高度差不超过1。因此，它能够在logn的平均时间内完成插入、删除、查询操作，但是在维护平衡的过程中，需要频繁地进行旋转操作，导致插入删除效率较低。

  红黑树是一种近似平衡的二叉搜索树，它在保持高度平衡的同时，又能够保持较高的插入删除效率。红黑树通过节点着色和旋转操作来维护平衡。红黑树在维护平衡的过程中，能够进行较少的节点旋转操作，因此插入删除效率较高，并且查询效率也较高。

  综上所述，红黑树具有较高的综合性能，是一种广泛应用的数据结构。



本文是博主的粗浅理解，可能存在一些错误或不完善之处，如有遗漏或错误欢迎各位补充，谢谢

  如果觉得这篇文章对您有所帮助的话，请动动小手点波关注💗，你的点赞👍收藏⭐️转发🔗评论📝都是对博主最好的支持~


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

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

相关文章

Python如何递归删除空文件夹

Python如何递归删除空文件夹

嗨喽&#xff0c;大家好呀~这里是爱看美女的茜茜呐 1.Python如何递归删除空文件夹&#xff0c;这个问题很常见。 但大多数人的解决办法都是自己实现递归函数解决这个问题&#xff0c;其实根本不用那么麻烦。 Python中的os.walk提供了一种从内到外的遍历目录树的方法&#xff…
阅读更多...
fullcalendar案例

fullcalendar案例

fullcalendar案例 <script srchttps://cdn.jsdelivr.net/npm/fullcalendar6.1.10/index.global.min.js></script><script srchttps://code.jquery.com/jquery-3.6.0.min.js></script> <!-- 引入 jQuery CDN --><script>document.addEventL…
阅读更多...
第5章 python深度学习——波斯美女

第5章 python深度学习——波斯美女

第5章 深度学习用于计算机视觉 本章包括以下内容&#xff1a; 理解卷积神经网络&#xff08;convnet&#xff09; 使用数据增强来降低过拟合 使用预训练的卷积神经网络进行特征提取 微调预训练的卷积神经网络 将卷积神经网络学到的内容及其如何做出分类决策可视化 本章将…
阅读更多...
【前端-VUE】Vue3组件组成部分及组件通信（详解）

【前端-VUE】Vue3组件组成部分及组件通信（详解）

一、父子间通信 1.父传子&#xff1a; 2.子传父&#xff1a; 3.什么是prop Prop定义&#xff1a;组件上注册的一些自定义属性 Prop作用&#xff1a;向子组件传递数据 特点&#xff1a; 可以传递任意数量的prop可以传递任意类型的prop 3.1 props校验 思考&#xff1a;组件的prop…
阅读更多...
母排设计时没有柜体3D数据？来试试SuperPanel的钣金功能！

母排设计时没有柜体3D数据？来试试SuperPanel的钣金功能！

CAD版SuperPanel软件能够助力用户快速、准确地设计和修改母排&#xff0c;同时快速输出加工图纸和数控加工代码。在壳体外购&#xff0c;没有柜体3D数据的情况下&#xff0c;如何轻松进行母排设计&#xff1f;一起来学习利驰数字母排的钣金功能吧&#xff01; SuperPanel的钣金…
阅读更多...
【新课】安装部署系列Ⅲ—Oracle 19c Data Guard部署之两节点RAC部署实战

【新课】安装部署系列Ⅲ—Oracle 19c Data Guard部署之两节点RAC部署实战

本课程由云贝教育-刘峰老师出品&#xff0c;感谢关注 课程介绍 Oracle Real Application Clusters (RAC) 是一种跨多个节点分布数据库的企业级解决方案。它使组织能够通过实现容错和负载平衡来提高可用性和可扩展性&#xff0c;同时提高性能。本课程基于当前主流版本Oracle 1…
阅读更多...
python 写入csv文件 内容乱码

python 写入csv文件 内容乱码

问题 python 写入csv文件 内容乱码 详细问题 笔者核心代码 import csv # 将数据写入 CSV 文件 csv_file_path "soil_data.csv" header ["经度", "纬度", "土壤类型", "pH值"]with open(csv_file_path, mode"w&q…
阅读更多...
【PyTorch实战演练】Fast R-CNN中的RoI(Region of Interest)池化详解

【PyTorch实战演练】Fast R-CNN中的RoI(Region of Interest)池化详解

文章目录 0. 前言1. ROI池化的提出背景2. RoI池化的结构与工作原理3. RoI池化的作用及意义4. RoI使用示例 0. 前言 按照国际惯例&#xff0c;首先声明&#xff1a;本文只是我自己学习的理解&#xff0c;虽然参考了他人的宝贵见解及成果&#xff0c;但是内容可能存在不准确的地方…
阅读更多...
优化器刺客之limit 1--Order by col limit n 代价预估优化探索

优化器刺客之limit 1--Order by col limit n 代价预估优化探索

一、现象 order by 排序加了limit后更慢了&#xff1f; test# explain analyze select userid from dba_users where username like %aaaaaaaaaaaaaaaaaa% order by userid ;QUERY PLAN --------------…
阅读更多...
ElementUI Form：Radio 单选框

ElementUI Form：Radio 单选框

ElementUI安装与使用指南 Radio 单选框 点击下载learnelementuispringboot项目源码 效果图 el-radio.vue 页面效果图 项目里el-radio.vue代码 <script> export default {name: el_radio,data() {return {radio: 1,radio2: 2,radio3: 3,radio4: 上海,radio5: 上海,ra…
阅读更多...
12个适合后端程序员的前端框架

12个适合后端程序员的前端框架

前言 今天我们分享12个适合后端程序员的前端框架&#xff0c;本文中的所有前端框架都已经收录到适合后端程序员的前端框架GitHub Issues知识库中&#xff0c;假如大家有更好前端框架推荐欢迎到以下GitHub项目地址留言或者在文末留言&#xff08;注意&#xff1a;排名不分先后&a…
阅读更多...
c#鼠标绘制

c#鼠标绘制

有用的没用的&#xff0c;用的上的用不上的&#xff0c;能写的不能写的&#xff0c;反正想起来就写了&#xff0c;比如这篇&#xff0c;好像一般也没什么用&#xff0c;emmm&#xff0c;或许&#xff0c;做录制软件的时候可以用一下。 顾名思义&#xff0c;本篇主要就是来实现将…
阅读更多...
dvwa，xss反射型lowmedium

dvwa，xss反射型lowmedium

xss&#xff0c;反射型&#xff0c;low&&medium low发现xss本地搭建实操 medium作为初学者的我第一次接触比较浅的绕过思路high low 发现xss 本关无过滤 <script>alert(/xss/)</script> //或 <script>confirm(/xss/)</script> //或 <scr…
阅读更多...
幻兽帕鲁服务器游戏怎么升级版本？

幻兽帕鲁服务器游戏怎么升级版本？

幻兽帕鲁服务器游戏怎么升级版本&#xff1f;自建幻兽帕鲁服务器进入Palworld游戏提示“您正尝试加入的比赛正在运行不兼容的游戏版本&#xff0c;请尝试升级游戏版本”什么原因&#xff1f;这是由于你的客户端和幻兽帕鲁服务器版本不匹配&#xff0c;如何解决&#xff1f;更新…
阅读更多...
故障诊断 | 一文解决，SVM支持向量机的故障诊断（Matlab）

故障诊断 | 一文解决，SVM支持向量机的故障诊断（Matlab）

效果一览 文章概述 故障诊断 | 一文解决，SVM支持向量机的故障诊断（Matlab） 支持向量机（Support Vector Machine，SVM）是一种常用的监督学习算法，用于分类和回归分析。SVM的主要目标是找到一个最优的超平面（或者在非线性情况下是一个最优的超曲面），将不同类别的样本分开…
阅读更多...
Flutter的安装与环境配置

Flutter的安装与环境配置

一、下载安装Futter&#xff1a; 1、Flutter中文文档&#xff1a; 安装和环境配置 - Flutter 中文文档 - Flutter 中文开发者网站 - Flutter 2、下载 Futter SDK&#xff1a; Flutter中文文档 里面有&#xff0c;下载完成之后找个文件夹解压出来&#xff0c;最好不要将 Flu…
阅读更多...
大数据分析|从七个特征理解大数据分析

大数据分析|从七个特征理解大数据分析

文献来源&#xff1a;Saggi M K, Jain S. A survey towards an integration of big data analytics to big insights for value-creation[J]. Information Processing & Management, 2018, 54(5): 758-790. 下载链接&#xff1a;链接&#xff1a;https://pan.baidu.com/s/1…
阅读更多...
qiankun子应用静态资源404问题有效解决（遇到了http请求静态文件404、css文件引用图片无法显示、svg图片转换成 base64无法显示等问题）

qiankun子应用静态资源404问题有效解决（遇到了http请求静态文件404、css文件引用图片无法显示、svg图片转换成 base64无法显示等问题）

在&#x1f449;&#x1f3fb; qiankun微前端部署&#x1f448;&#x1f3fb;这个部署方式的前提下&#xff0c;遇到的问题并解决问题的过程 >> 问题现象 通过http请求本地的静态json文件404 css中部分引入的图片无法显示 >> 最开始的解决方式 在&#x1f449;…
阅读更多...
微信小程序（二十五）条件判断语句与结构隐藏

微信小程序（二十五）条件判断语句与结构隐藏

注释很详细&#xff0c;直接上代码 上一篇 新增内容&#xff1a; 1.条件判断语句的演示 2.隐藏结构的演示 源码&#xff1a; index.wxml <view><!-- wx:if和wx:else为条件判断语句 --><text wx:if"{{isLogin}}">已登入的用户</text><tex…
阅读更多...
【HarmonyOS应用开发】ArkUI 开发框架-基础篇-第一部分（七）

【HarmonyOS应用开发】ArkUI 开发框架-基础篇-第一部分（七）

常用基础组件 一、组件介绍 组件&#xff08;Component&#xff09;是界面搭建与显示的最小单位&#xff0c;HarmonyOS ArkUI声明式开发范式为开发者提供了丰富多样的UI组件&#xff0c;我们可以使用这些组件轻松的编写出更加丰富、漂亮的界面。组件根据功能可以分为以下五大类…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023