一、红黑树性质
1.每个节点要么是红色，要么是黑色
2.根节点必须是黑色
3.红色节点不能连续（父子不能同红）
4.每个叶结点（包括null节点）都是黑的
5.从任意节点出发，到其所有叶子节点的简单路径上都包含相同数目的黑色节点（重点）
二、浅谈：
-
插入节点：新插入节点是红色的（-若是根节点就变黑-），再插一个就是双红（----性质3----此时需要变色+旋转）。
-
旋转：树的旋转本质是节点的指向发生变化，代码+画图思路就十分清晰
可以用iodraw或者processon在线画图；
注意根节点：判断方法----只有根节点没有父节点左旋(红色线是要断开重组的)：
右旋：
-
红黑树可视化：在线画红黑树，用来判断自己的程序是否正确
三、代码
ps: 代码是我从gitee（@vlaidwk）搞来的（基本是原厂），代码中有详细注释（但需要一定基础）;
package RBT;
import java.util.Scanner;
public class RBTreeTest{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
RBTree<Integer, Object> rbt = new RBTree();
while (true) {
System.out.println("input key:");
String key = sc.next();
rbt.insert(Integer.parseInt(key), null);
TreeOperation.show(rbt.getRoot());
}
}
}
package RBT;
/**
* ①创建RBTree，定义颜色
* ②创建RBNode
* ③辅助方法定义：parentOf(node)，isRed(node)， isBlack(node) ，setRed(node)，setBlack(node)，inOrderPrint()
* ④左旋方法定义：leftRotate(node)
* ⑤右旋方法定义：rightRotate(node)
* ⑥公开插入接口方法定义：insert(K key, V value);
* ⑦内部插入接口方法定义：insert(RBNode node);
* ⑧修正插入导致红黑树失衡的方法定义：insertFIxUp(RBNode noe);
* ⑨测试红黑树正确性
*/
public class RBTree<K extends Comparable<K>, V> {
private static final boolean RED = true;
private static final boolean BLACK = false;
private RBNode root; //树根的引用
public RBNode getRoot() {
return root;
}
/**
* 节点是否为红色/黑色
*/
private boolean isRed(RBNode node) {
if (node != null) {
return node.color == RED;
}
return false;
}
private boolean isBlack(RBNode node) {
if (node != null) {
return node.color == BLACK;
}
return false;
}
/**
* 设置节点为红色/黑色
*/
private void setRed(RBNode node) {
if (node != null) {
node.color = RED;
}
}
private void setBlack(RBNode node) {
if (node != null) {
node.color = BLACK;
}
}
/**
* 中序打印二叉树
*/
public void inOrderPrint() {
inOrderPrint(this.root);
}
private void inOrderPrint(RBNode node) {
if (node != null) {
inOrderPrint(node.left);
System.out.println("key:" + node.key + ",value" + node.value);
inOrderPrint(node.right);
}
}
/**
* 公开的插入方法
*/
public void insert(K key, V value) {
RBNode node = new RBNode();
node.setKey(key);
node.setValue(value);
//新节点一定是红色
node.setColor(RED);
insert(node);
}
private void insert(RBNode node) {
//查找当前node的插入位置
RBNode parent = null;
RBNode x = this.root;
while (x != null) {//空
parent = x;//找到当前node的父节点
//a > b 则返回 1，否则返回 -1 ，相等返回0
int cmp = node.key.compareTo(x.key);
if (cmp < 0) {
x = x.left;//向左继续查找
} else if (cmp == 0) {
parent.setValue(node.value);
return;
} else {
x = x.right;//向右继续查找
}
}
node.parent = parent;
//判断node应该插入到parent的左边还是右边
if (parent != null) {
if (node.key.compareTo(parent.key) < 0) {
parent.left = node;
} else {
parent.right = node;
}
} else {//为空树,定义node为root
this.root = node;
}
//插入之后需要进行修复红黑树，让红黑树再次平衡。
insertFixUp(node);
}
/*
* 前驱节点后继节点(没有考虑往上找)
*/
private RBNode predecessor(RBNode x) {
RBNode y = x.left;
if (y != null) {
while (y.right != null) {
y = y.right;
}
return y;
}
return null;
}
private RBNode successor(RBNode x) {
RBNode y = x.right;
if (y != null) {
while (y.left != null) {
y = y.left;
}
return y;
}
return null;
}
/**
* ---删除节点---
* 子节点：无子节点、有一个子节点、有两个子节点；自身颜色：红色，黑色；有6种组合
* https://blog.csdn.net/qq_40843865/article/details/102498310
*/
/**
* 插入后修复红黑树平衡的方法
* |---情景1：红黑树为空树,将根节点染色为黑色
* |---情景2：插入节点的key已经存在，不需要处理，前面returen掉了
* |---情景3：插入节点的父节点为黑色，红黑树仍然平衡，不需要处理
* 以上不用管，以下需要咱们去处理
* |---情景4：插入节点的父节点为红色
* |---情景4.1：叔节点存在，并且为红色（父-叔 双红）,将父叔节点染色为黑色，将爷节点染色为红色，再以爷节点为当前节点进行下一步处理
* |---情景4.2：叔节点不存在，或者为黑色，父节点为爷节点的左子树
* |---情景4.2.1：插入节点为其父节点的左子节点（LL情况）,将父节点染色为黑色，将爷节点染色为红色,然后以爷节点右旋处理
* |---情景4.2.2：插入节点为其父节点的右子节点（LR情况），以父节点左旋，变成LL情况，然后指定父节点为当前节点进行下一步处理
* |---情景4.3：叔节点不存在，或者为黑色，父节点为爷节点的右子树
* |---情景4.3.1：插入节点为其父节点的右子节点（RR情况），将父节点染色为黑色，将爷节点染色为红色，然后以爷节点左旋处理
* |---情景4.3.2：插入节点为其父节点的左子节点（RL情况），以父节点右旋，变成RR情况，然后指定父节点为当前节点进行下一步处理
*/
private void insertFixUp(RBNode node) {
RBNode parent = parentOf(node);
RBNode gparent = parentOf(parent);
//存在父节点且父节点为红色
if (parent != null && isRed(parent)) {
//父节点是红色的，那么一定存在爷节点
//父节点为爷节点的左子树
if (parent == gparent.left) {
RBNode uncle = gparent.right;
//4.1：叔节点存在，并且为红色（父-叔 双红）
//将父和叔染色为黑色，再将爷染红，并将爷设置为当前节点，进入下一次循环判断
if (uncle != null && isRed(uncle)) {
setBlack(parent);
setBlack(uncle);
setRed(gparent);
insertFixUp(gparent);
return;
}
//叔节点不存在，或者为黑色
else {
if (node == parent.left) {
//插入节点为其父节点的左子节点（LL情况）=>
//变色（父节点变黑，爷节点变红），右旋爷节点
setBlack(parent);
setRed(gparent);
rightRotate(gparent);
} else {
//插入节点为其父节点的右子节点（LR情况）=>
//左旋（父节点），当前节点设置为父节点，进入下一次循环
leftRotate(parent);
insertFixUp(parent);
return;
}
}
} else {//父节点为爷节点的右子树
RBNode uncle = gparent.left;
//4.1：叔节点存在，并且为红色（父-叔 双红）
if (uncle != null && isRed(uncle)) {
setBlack(parent);
setBlack(uncle);
setRed(gparent);
insertFixUp(gparent);
return;
}
//叔节点不存在，或者为黑色，父节点为爷节点的右子树
else {
if (node == parent.left) {
rightRotate(parent);
insertFixUp(parent);
return;
} else {
setBlack(parent);
setRed(gparent);
leftRotate(gparent);
}
}
}
}
setBlack(this.root);
}
/**
* 左旋右旋方法
*/
private void leftRotate(RBNode x) {
RBNode y = x.right;
//将x的右子节点指向y的左子节点
x.right = y.left;
//将y的左子节的父节点更新为x
if (y.left != null) {
y.left.parent = x;
}
//当x的父节点不为空时，将x的父节点指向y，并将x父节点的子树指向y
if (x.parent != null) {
y.parent = x.parent;
if (x == x.parent.left) {
x.parent.left = y;
} else {
x.parent.right = y;
}
} else {//说明x为根节点，此时更新y为根节点
this.root = y;
this.root.parent = null;
}
//将x的父节点更新为y，将y的左节点更新为x
x.parent = y;
y.left = x;
}
private void rightRotate(RBNode y) {
//1.将x的右子节点赋值给y的左子节点，并将y赋值给x右子节点的父节点（x右子节点非空时）
RBNode x = y.left;
y.left = x.right;
if (x.right != null) {
x.right.parent = y;
}
//2.将y的父节点（不为空时）指向x，更新x的父节点为y的父节点
if (y.parent != null) {
x.parent = y.parent;
if (y.parent.left == y) {
y.parent.left = x;
} else {
y.parent.right = x;
}
} else {//y为根节点
this.root = x;
}
//3.将x的右子节点指向y，更新y的父节点为x
x.right = y;
y.parent = x;
}
//返回父节点
private RBNode parentOf(RBNode node) {
if (node != null) {
return node.parent;
}
return null;
}
static class RBNode<K extends Comparable<K>, V> {
private RBNode parent;
private RBNode left;
private RBNode right;
private boolean color;
private K key;
private V value;
public RBNode() {
}
public RBNode getParent() {
return parent;
}
public void setParent(RBNode parent) {
this.parent = parent;
}
public RBNode getLeft() {
return left;
}
public void setLeft(RBNode left) {
this.left = left;
}
public RBNode getRight() {
return right;
}
public void setRight(RBNode right) {
this.right = right;
}
public boolean isColor() {
return color;
}
public void setColor(boolean color) {
this.color = color;
}
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public V getValue() {
return value;
}
public void setValue(V value) {
this.value = value;
}
}
}
package RBT;
public class TreeOperation {
// 用于获得树的层数
public static int getTreeDepth(RBTree.RBNode root) {
return root == null ? 0 : (1 + Math.max(getTreeDepth(root.getLeft()), getTreeDepth(root.getRight())));
}
private static void writeArray(RBTree.RBNode currNode, int rowIndex, int columnIndex, String[][] res, int treeDepth) {
// 保证输入的树不为空
if (currNode == null) return;
// 先将当前节点保存到二维数组中 红色：\033[31m 黑色：\033[30m 默认：033[m ps:超过三位数会错位
res[rowIndex][columnIndex] = String.valueOf((currNode.isColor() ? "\033[31m" : "\033[30m") + currNode.getKey() + " \033[m");
// 计算当前位于树的第几层
int currLevel = ((rowIndex + 1) / 2);
// 若到了最后一层，则返回
if (currLevel == treeDepth) return;
// 计算当前行到下一行，每个元素之间的间隔（下一行的列索引与当前元素的列索引之间的间隔）
int gap = treeDepth - currLevel - 1;
// 对左儿子进行判断，若有左儿子，则记录相应的"/"与左儿子的值
if (currNode.getLeft() != null) {
res[rowIndex + 1][columnIndex - gap] = "/";
writeArray(currNode.getLeft(), rowIndex + 2, columnIndex - gap * 2, res, treeDepth);
}
// 对右儿子进行判断，若有右儿子，则记录相应的"\"与右儿子的值
if (currNode.getRight() != null) {
res[rowIndex + 1][columnIndex + gap] = "\\";
writeArray(currNode.getRight(), rowIndex + 2, columnIndex + gap * 2, res, treeDepth);
}
}
public static void show(RBTree.RBNode root) {
if (root == null) System.out.println("EMPTY!");
// 得到树的深度
int treeDepth = getTreeDepth(root);
// 最后一行的宽度为2的（n - 1）次方乘3，再加1
// 作为整个二维数组的宽度
int arrayHeight = treeDepth * 2 - 1;
int arrayWidth = (2 << (treeDepth - 2)) * 3 + 1;
// 用一个字符串数组来存储每个位置应显示的元素
String[][] res = new String[arrayHeight][arrayWidth];
// 对数组进行初始化，默认为一个空格
for (int i = 0; i < arrayHeight; i++) {
for (int j = 0; j < arrayWidth; j++) {
res[i][j] = " ";
}
}
// 从根节点开始，递归处理整个树
// res[0][(arrayWidth + 1)/ 2] = (char)(root.val + '0'); 这行不知道干嘛的
writeArray(root, 0, arrayWidth / 2, res, treeDepth);
// 此时，已经将所有需要显示的元素储存到了二维数组中，将其拼接并打印即可
for (String[] line : res) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < line.length; i++) {
sb.append(line[i]);
if (line[i].length() > 1 && i <= line.length - 1) {
i += line[i].length() > 4 ? 2 : line[i].length() - 1;
}
}
System.out.println(sb.toString());
}
}
}
967
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
