红黑树性质:
1.每个节点要么是黑色要么是红色
2.根节点石黑色
3.每个叶子结点是黑色
4.每个红节点的两个子节点一定是黑色，不能有两个红色节点相连
5.任何一节点到每个叶子节点的路径都包含相同的黑节点
三种操作：左旋、右旋和变色。
1.变色：结点的颜色由红变黑或由黑变红。
2.左旋：以某个结点作为支点(旋转结点)，其右子结点变为旋转结点的父结点，右子结点的左子结点变为旋转结点的右子结点，左子结点保持不变。
3.右旋：以某个结点作为支点(旋转结点)，其左子结点变为旋转结点的父结点，左子结点的右子结点变为旋转结点的左子结点，右子结点保持不变
左旋
右旋
红黑树插入节点情景分析
.插入节点，必须为红色
情景1：红黑树为空树
最简单的一种情景，直接把插入结点作为根结点就行
注意：根据红黑树性质2：根节点是黑色。还需要把插入结点设为黑色。
情景2：插入结点的Key已存在
处理：更新当前节点的值，为插入节点的值
情景3：插入结点的父结点为黑结点
由于插入的结点是红色的，当插入结点的黑色时，并不会影响红黑树的平衡，直接插入即可，无需做自平衡。
情景4：插入节点的父节点为红色
再次回想下红黑树的性质2：根结点是黑色。如果插入节点的父结点为红结点，那么该父结点不可能为根结点，所以插入结点总是存在祖父结点。
这一点很关键，因为后续的旋转操作肯定需要祖父结点的参与。
插入情景4.1：叔叔结点存在并且为红结点
依据红黑树性质4可知，红色节点不能相连 ==> 祖父结点肯定为黑结点；
因为不可以同时存在两个相连的红结点。那么此时该插入子树的红黑层数的情况是：黑红红。显然最简单的处理方式是把其改为：红黑红
处理：
1.将P和U节点改为黑色
2.将PP改为红色
3.将PP设置为当前节点，进行后续处理
可以看到，我们把PP结点设为红色了，如果PP的父结点是黑色，那么无需再做任何处理；
但如果PP的父结点是红色，则违反红黑树性质了。所以需要将PP设置为当前节点，继续做插入操作自平衡处理，直到平衡为止。
插入情景4.2： 下面插入节点均为I节点
叔叔结点不存在或为黑结点，并且插入结点的父亲结点是祖父结点的左子结点
注意：单纯从插入前来看，叔叔节点非红即空（NIL节点），否则的话破坏了红黑树性质5，此路径会比其它路径多一个黑色节点。
插入情景4.2.1：新插入节点，为其父节点的左子节点（LL红色情况）
处理：
1.变颜色：将P设置为黑色，将PP设置为红色
2.对PP节点进行右旋
插入情景4.2.2：新插入节点，为其父节点的右子节点（LR红色情况）
处理：
1.对P进行左旋
2.将P设置为当前节点，得到LL红色情况
3.按照LL红色情况处理（1.变颜色 2.右旋PP）
插入情景4.3：叔叔结点不存在或为黑结点，并且插入结点的父亲结点是祖父结点的右子结点
插入情景4.3.1：新插入节点，为其父节点的右子节点（RR红色情况）
处理：
1.变颜色：将P设置为黑色，将PP设置为红色
2.对PP节点进行左旋
插入情景4.3.2：新插入节点，为其父节点的左子节点（RL红色情况）
处理：
1.对P进行右旋
2.将P设置为当前节点，得到RR红色情况
3.按照RR红色情况处理（1.变颜色 2.左旋PP）
代码实现
package com.wfs.suanfa.leet;
/**
* 红黑树
* 1.创建RBTree，定义颜色
* 2.创建RBNode
* 3.辅助方法定义: parentOf(node),isRead(node),isBlack(node),setRed(node),isOrderPrint()
* 4.左旋方法
* 5.右旋转方法
* 6.公开插入接口方法 insert(k,v)
* 7.内部插入方法
* 8.修订插入导致红黑树失衡的方法定义 insertFIxUp(RBNode node)
* 9.测试红黑树正确
*/
public class RBTree<K extends Comparable<K>,V> {
private static final boolean RED=true;
private static final boolean BLACK=false;
public 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 vaule;
public RBNode(RBNode parent, RBNode left, RBNode right, boolean color, K key, V vaule) {
this.parent = parent;
this.left = left;
this.right = right;
this.color = color;
this.key = key;
this.vaule = vaule;
}
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 getVaule() {
return vaule;
}
public void setVaule(V vaule) {
this.vaule = vaule;
}
}
/**
* 树根的引用
*/
private RBNode root;
/**
* 获取当前父节点
* @param node
*/
private RBNode parentOf(RBNode node){
if (node!=null){
return node.parent;
}
return null;
}
/**
* 是否为红色
*/
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);
}
public void inOrderPrint(RBNode root){
if (root!=null){
inOrderPrint(root.left);
System.out.println("key:"+root.key+",valuel:"+root.vaule);
inOrderPrint(root.right);
}
}
/**
* 左旋方法
* 左旋示意图 左旋X节点
* P P
* | |
* X y
* / \ ---> / \
* lx y X ry
* /\ / \
* ly ry lx ly
* 1.将x的右子节点 指向y的左子节点
* 2.当x的父节点不为空时，更新y的父节点为x父节点，并将x的节点 指定子树 指定为y
* 3.将x树父节点位置更新为y， 将y的左子节点更新为x
*
*
*/
private void leftRotate(RBNode x){
RBNode y = x.right;
//1.将x的右子节点 指向y的左子节点
x.right=y.left;
if (y.left!=null){
y.left.parent=x;
}
//2.当x的父节点不为空时，更新y的父节点为x父节点，并将x的节点 指定子树 指定为y
if (x.parent!=null){
y.parent=x.parent;
//将其x父节点的左 或右 子树位置更新为 y
if (x==x.parent.left){
x.parent.left=y;
}else {
x.parent.right=y;
}
}else {
this.root=y;
this.root.parent=null;
}
//3.将x树父节点位置更新为y， 将y的左子节点更新为x
x.parent=y;
y.left=x;
}
/**
* 右旋
* 右旋 右旋y节点
* P P
* | |
* Y X
* / \ ---> / \
* X ry lx Y
* /\ / \
* lx ly ly ry
*
* 1.将 y的左子节点指向x的右子节点，并且更新x的右子节点为y
* 2.Y的父节点不为空的时候 更新x的父节点为y父节点，更新y的父节点的指定节点位置为x
* 3.将Y的父节点更新为 x,将y的左子节点更新为x的右子节点
*/
private void rightRotate(RBNode y){
RBNode x = y.left;
//1.将 y的左子节点指向x的右子节点，并且更新x的右子节点为y
y.left=x.right;
if (x.right!=null){
x.right.parent=y;
}
// 2.Y的父节点不为空的时候 更新x的父节点为y父节点，更新y的父节点的指定节点位置为x
if (y.parent!=null){
x.parent=y.parent;
if (y.parent.left==y){
y.parent.left=x;
}else {
y.parent.right=x;
}
}else {
this.root=x;
this.root.parent=null;
}
//3.将Y的父节点更新为 x,将y的左子节点更新为x的右子节点
y.parent=x;
x.right=y;
}
/**
* 公开的插入方法
*/
public void insert(K key,V value){
RBNode rbNode=new RBNode();
rbNode.setKey(key);
rbNode.setVaule(value);
//新节点一定为红色
rbNode.setColor(RED);
insert(rbNode);
}
/**
* 内部有的插入方法
*/
private void insert(RBNode node){
//第一步 查看当前节点 node的父节点
RBNode parent=null;
RBNode x=this.root;
while (x!=null){
parent=x;
//cmp>0 说明node.key大于 x.key,需要将到x的右子树查找
// cmp>==0 说明node.key等于 x.替换操作
//cmp<0 说明node.key大于 x.key,需要将到x的左子树查找
int cmp=node.key.compareTo(x.key);
if (cmp>0) {
x=x.right;
}else if (cmp==0){
x.setVaule(node.getVaule());
return;
}else {
x=x.left;
}
}
node.parent=parent;
if (parent!=null){
int cmp=node.key.compareTo(parent.key);
if (cmp>0) {
parent.right=node;
}else {
parent.left=node;
}
}else {
this.root=node;
this.root.parent=null;
}
//修复红黑树平衡问题
insertFIxUp(node);
}
/**
* 插入后修复红黑树平衡的方法
* 情景
* 1.为空树 将根节点设置为黑色
* 2.插入节点key存在 不做处理
* 3.插入节点的父亲节点为黑色 黑色节点无变化 直接做插入
*
*
* 4.其他情况
* 1.插入节点的父亲节点为红色·
* 1.1:叔叔节点存在，并且为红色 叔父 双红
* 处理:将叔父节点染色为黑色，将爷爷染色为红色，并且再以爷爷为当前节点进行下一轮处理
* 1.2 叔叔节点不存在或者为黑色，父亲为爷爷节点的左子树
* 1.2.1:插入节点为其父亲的左子节点(LL情况)
* 处理:将父亲节点染色为黑色，爷爷节点染色为红色，然后以爷爷节点右旋
* 1,2.2:插入节点的为父亲的右子节点(LR情况)
* 处理:以父亲节点进行一次左旋得到 LL双红情况，然后指定父亲节点为当前节点进行下一轮 处理
* 1.3.叔叔节点不存在或者为黑色，父亲为爷爷节点的右子树
* 1.3.1:插入节点的为父亲的右子节点(RR情况)
* 处理:将父亲节点染色为黑色爷爷节点变红，对爷爷节点进行左旋
* 1.3.2:插入节点为其父亲的左子节点(RL情况)
* 处理:将父亲节点进行一次右旋等到 (RR双红情况)，然后以父亲节点为当前节点进行下一轮处理
*/
private void insertFIxUp(RBNode node){
this.root.setColor(BLACK);
RBNode parnet=parentOf(node);
RBNode gparnet=parentOf(parnet);
//插入节点的父亲节点为红色·
if (parnet!=null && isRed(parnet)){
//如果父节点为红色 一定有爷爷节点，因为根节点不可能为红
RBNode uncle=null;
//插入节点 父亲为左子树
if (parnet==gparnet.left){
uncle=gparnet.right;
//4.1.1:叔叔节点存在，并且为红色 叔父 双红
if (uncle!=null && isRed(uncle)){
// 处理:将叔父节点染色为黑色，将爷爷染色为红色，并且再以爷爷为当前节点进行下一轮处理
setBlack(parnet);
setBlack(uncle);
setRed(gparnet);
insertFIxUp(gparnet);
return;
}
// 4.1.2 叔叔节点不存在或者为黑色，
if (uncle==null || isBlack(uncle)){
//4 1.2.1:插入节点为其父亲的左子节点(LL情况)
// 处理:将父亲节点染色为黑色，爷爷节点染色为红色，然后以爷爷节点右旋
if (node==parnet.left){
setBlack(parnet);
setRed(gparnet);
rightRotate(gparnet);
return;
}
//4 1,2.2:插入节点的为父亲的右子节点(LR情况)
//处理:以父亲节点进行一次左旋得到 LL双红情况，然后指定父亲节点为当前节点进行下一轮 处理
if (node==parnet.right){
leftRotate(parnet);
insertFIxUp(parnet);
return;
}
}
}else {
uncle=gparnet.left;
//处理:将叔父节点染色为黑色，将爷爷染色为红色，并且再以爷爷为当前节点进行下一轮处理
if (uncle!=null && isRed(uncle)){
// 处理:将叔父节点染色为黑色，将爷爷染色为红色，并且再以爷爷为当前节点进行下一轮处理
setBlack(parnet);
setBlack(uncle);
setRed(gparnet);
insertFIxUp(gparnet);
return;
}
// 1.3.叔叔节点不存在或者为黑色
if (uncle==null || isBlack(uncle)){
//4 1.3.1:插入节点的为父亲的右子节点(RR情况)
// 处理:将父亲节点染色为黑色爷爷节点变红，对爷爷节点进行左旋
if (node==parnet.right){
setBlack(parnet);
setRed(gparnet);
leftRotate(gparnet);
return;
}
//4 1.3.2:插入节点为其父亲的左子节点(RL情况)
// 处理:将父亲节点进行一次右旋等到 (RR双红情况)，然后以父亲节点为当前节点进行下一轮处理
if (node==parnet.left){
rightRotate(parnet);
insertFIxUp(parnet);
return;
}
}
}
}
}
public RBNode getRoot() {
return root;
}
}
package com.wfs.suanfa.util;
import com.wfs.suanfa.leet.RBTree;
public class TreePrintUtil {
/*
树的结构示例：
1
/ \
2 3
/ \ / \
4 5 6 7
*/
// 用于获得树的层数
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;
// 先将当前节点保存到二维数组中
res[rowIndex][columnIndex] = String.valueOf(currNode.getKey()+ (currNode.isColor() ? "R" : "B") + "");
// 计算当前位于树的第几层
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());
}
}
}
635
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
