本文详细讲解了二叉树、二叉排序树（BST）的插入与删除规则，深入剖析了完全二叉树的性质和判断方法，重点介绍了平衡二叉树（AVL）和红黑树(RBTree)的性质、旋转操作及插入步骤。通过实例演示，展示了这些数据结构在实际编程中的应用。
目录
一、二叉树
每个节点最多有两个叶子节点的树是二叉树。
二、二叉排序树(BST)
也叫二叉查找树和二叉搜索树
性质：
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉排序树
插入规则：
比父节点小的值放左边，比父节点大的值，放右边，一个父节点最多只能有两个子节点
删除规则：
- 删除叶子节点，直接删除
- 删除只有左子树或者是有右子树的节点，删除节点，左子树或者右子树直接接上
- 删除有左子树和右子树的节点P，找到删除节点的直接后继节点H，节点H替换节点P，删除原来的P节点
（PS：直接后继节点：中序遍历，在删除节点P后一位的节点为直接后继节点）
二叉查找树代码实现：
/**
* @author Admin
*/
public class BSTTree {
/**
* 定义二叉树
*/
class Node{
public int iData;
public double dData;
public Node leftNode;
public Node rightNode;
public void showNode(){
System.out.println("{"+iData+","+dData+"}");
}
}
private Node root;
/**
* 插入节点
* 规则：比父节点小的值放左边，比父节点大的值，放右边，一个父节点最多只能有两个子节点
* @param iData
* @param dData
*/
public void insert(int iData,double dData){
Node newNode = new Node();
newNode.iData = iData;
newNode.dData = dData;
if(root==null){
root = newNode;
}else{
Node current = root;
Node parent;
while (true){
parent = current;
//插入左节点
if(iData< current.iData){
current=current.leftNode;
if(current==null){
parent.leftNode=newNode;
return;
}
}else{//插入右节点
current=current.rightNode;
if(current==null){
parent.rightNode = newNode;
return;
}
}
}
}
}
/**
* 查找节点
* @param key
* @return
*/
public Node find(int key){
Node current = root;
if(current==null){
return new Node();
}
while(current.iData!=key){
if(current.iData>key){
current=current.leftNode;
}else{
current=current.rightNode;
}
if(current==null){
return new Node();
}
}
return current;
}
/**
* 规则:
* 1、删除叶子节点，直接删除
* 2、删除只有左子树或者是有右子树的节点，删除节点，左子树或者右子树直接接上
* 3、删除有左子树和右子树的节点P，找到删除节点的直接后继节点H，节点H替换节点P，删除原来的P节点
* 直接后继节点：中序遍历，在节点P后一位的节点为直接后继节点
* @param key
*/
public void delete(int key){
//找到需要删除的节点
Node current = find(key);
Node parent = current==null?null:current.parentNode;
if(current!=null){
//删除节点的左子树不为空
if(current.leftNode != null && current.rightNode != null){
//查询待删除节点的直接后继节点
Node successorNode = getSuccessorNode(current);
//保存节点数据，便于后面的替换
int iData = successorNode.iData;
double dData = successorNode.dData;
//删除该后继节点
delete(successorNode.iData);
//替换节点
current.iData = iData;
current.dData = dData;
}else if(current.leftNode != null || current.rightNode != null){
//删除含有左子树或者右子树的节点,将删除节点的父节点直接连接删除节点的左子树或者右子树
if(current.leftNode!=null){
current.leftNode.parentNode = parent;
}else{
current.rightNode.parentNode = parent;
}
if(parent!=null){
if(parent.iData>current.iData){
parent.leftNode = current.leftNode != null?current.leftNode:current.rightNode;
}else{
parent.rightNode = current.leftNode != null?current.leftNode:current.rightNode;
}
}else{
//删除节点为根节点，直接将根节点替换为下一个节点
if(current.leftNode!=null){
root = current.leftNode;
}else{
root = current.rightNode;
}
}
}else{
//删除叶子节点
if(parent==null){
//根节点，直接将树置空
root = null;
}else{
//删除叶子节点,直接置空
if(parent.iData>current.iData){
parent.leftNode = null;
}else{
parent.rightNode = null;
}
}
}
}
}
/**
* 获取节点的直接后继节点
* @param node
* @return
*/
public Node getSuccessorNode(Node node){
Node current = node==null?null:node.rightNode;
if(current==null){
return null;
}
while(current.leftNode!=null){
current = current.leftNode;
}
return current;
}
/**
* 查找树最小值和最大值
* @return
*/
public Node[] mVal(){
Node current = root;
Node maxCurrent = current;
Node minCurrent = current;
Node[] minAndMaxVal = new Node[2];
while(minCurrent.leftNode!=null){
minCurrent = minCurrent.leftNode;
}
minAndMaxVal[0]=minCurrent;
while(maxCurrent.rightNode!=null){
maxCurrent = maxCurrent.rightNode;
}
minAndMaxVal[1]=maxCurrent;
return minAndMaxVal;
}
}测试二叉查找树代码
public static void main(String[] args) {
// write your code here
BSTTree treeTest = new TreeTest();
treeTest.insert(3,3.03);
treeTest.insert(5,5.05);
treeTest.insert(1,1.01);
treeTest.insert(2,2.02);
treeTest.insert(4,4.04);
treeTest.insert(6,6.06);
//查找节点3
BSTTree.Node node = treeTest.find(5);
if(node == null){
System.out.println("can not find it");
}else{
node.showNode();
}
BSTTree.Node[] temp = treeTest.mVal();
temp[0].showNode();
temp[1].showNode();
//删除节点3
treeTest.delete(5);
//再次查找
BSTTree.Node node1 = treeTest.find(5);
if(node1 == null){
System.out.println("can not find it");
}else{
node1.showNode();
}
}结果：
三、完全二叉树
叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。
性质：
1、具有n个结点的完全二叉树的深度[log2n]+1
2、如果对一棵有n个结点的完全二叉树的结点按层序编号, 则对任一结点i (1≤i≤n) 有:
- 如果i=1, 则结点i是二叉树的根, 无双亲;如果i>1, 则其双亲parent (i) 是结点[i/2].
- 如果2i>n, 则结点i无左孩子, 否则其左孩子lchild (i) 是结点2i;
- 如果2i+1>n, 则结点i无右孩子, 否则其右孩子rchild (i) 是结点2i+1.
判断一棵树是否是完全二叉树的思路
1、如果树为空，则直接返回错
2、如果树不为空：层序遍历二叉树
2.1、如果一个结点左右孩子都不为空，则pop该节点，将其左右孩子入队列；
2.1、如果遇到一个结点，左孩子为空，右孩子不为空，则该树一定不是完全二叉树；
2.2、如果遇到一个结点，左孩子不为空，右孩子为空；或者左右孩子都为空，且则该节点之后的队列中的结点都为叶子节点，该树才是完全二叉树，否则就不是完全二叉树；
层次遍历代码(Java)---leetCode102:
static class TreeNode{
int val;
TreeNode left;
TreeNode right;
TreeNode(){}
TreeNode(int val){
this.val = val;
}
TreeNode(int val,TreeNode left,TreeNode right){
this.val = val;
this.left = left;
this.right = right;
}
public void showNode(){
System.out.println("{"+val+":"+((left==null)?null:left.val)+":"+((right==null)?null:right.val)+"}");
}
}
public static void main(String[] args) {
TreeNode tree1 = new TreeNode(9);
TreeNode tree2 = new TreeNode(15);
TreeNode tree3 = new TreeNode(7);
TreeNode tree4 = new TreeNode(20,tree2,tree3);
TreeNode tree5 = new TreeNode(3,tree1,tree4);
List<List<Integer>> res = new ArrayList<>();
Queue<TreeNode> queue = new LinkedList<>();
queue.add(tree5);
while (!queue.isEmpty()){
int count = queue.size();
List<Integer> list = new ArrayList<>();
while (count > 0) {
TreeNode node = queue.poll();
list.add(node==null?null:node.val);
if(node!=null && node.left!=null){
queue.add(node.left);
}
if(node!=null && node.right!=null){
queue.add(node.right);
}
count--;
}
res.add(list);
}
for (List<Integer> re : res) {
System.out.println(re);
}
}四、平衡二叉树（AVL）
性质：
1、是二叉排序树
2、每个节点的左子树和右子树的高度之差至多等于1，大于1则失衡，需要旋转纠正
旋转：
1、左旋
- 旧根节点为新根节点的左子树
- 新根节点的左子树为旧根节点的右子树
2、右旋
- 旧根节点为新根节点的右子树
- 新根节点的右子树为旧根节点的左子树
概念：
平衡因子(BF)：节点的左子树高度减右子树高度
最小不平衡子树：往平衡二叉树中插入新的节点，从插入点由下往上，依次遍历插入点的各个祖先节点，记录第一个遍历到的平衡因子的绝对值 |BF| >1的祖先节点，以该节点为根节点的子树，即为这棵树的最小不平衡子树。
4 种「旋转」纠正类型（只需纠正最小不平衡子树即可，最小不平衡子树是距离插入节点最近的，并且BF的绝对值大于1的节点为根节点的子树）：
- LL 型(关注BF=2,BF=1)：插入左孩子的左子树，右旋（BF为平衡因子，即左子树高度减右子树高度）
- RR 型(关注BF=-2,BF=-1)：插入右孩子的右子树，左旋
- LR 型(关注BF=2,BF=-1)：插入左孩子的右子树，先左旋，再右旋
- RL 型(关注BF=-2,BF=1)：插入右孩子的左子树，先右旋，再左旋
下图中，单个节点第一个值为节点数据，第二个是平衡因子BF
第一种：右旋，2为新根节点，3为2的右子树
第二种：先左旋，变为LL型（如下图），再右旋，2为新根节点，3为2的右子树
第三种：左旋，2为新根节点，1为2的左子树
第四种：先右旋，变成RR型（如下图），再左旋，2为新根节点，1为2的左子树
插入步骤：
- 生成二叉查找树
- 计算平衡因子，判断是否需要调整，以及如何调整（需要调整的情况就是上面列的四种类型）
删除规则：
- 删除节点为叶子节点时，更新该节点的父节点高度，以及往上所有父节点高度；
- 删除节点只有左子树或者右子树时，该删除节点下的左子树或右子树接上，并且更新原删除节点的父节点高度；
- 删除节点有左子树和右子树时，将该删除节点替换为删除节点的直接后继节点，并且回调本方法删除该后继节点；
- 删除后，需要从根节点往下，依次计算平衡因子，判断是否失衡，并调整
例题：{3,2,1,4,5,6,7,10,9,8}构造平衡二叉树
（以下只列了最难的一步转换，图中的节点，第一个数为保存的数据，第二个数为平衡因子）：
节点8插入过程
失衡，找到最小不平衡子树｛6,5,9,7,10,8｝，RL型（先右旋，再左旋），节点{6,9,7}右旋，7的右子树变为9的左子树如下图
节点｛6,7,9｝左旋，节点6变为节点7的左子树，得到结果
JAVA实现平衡二叉树的插入、删除等等操作以及测试代码
package com.examply;
import java.util.*;
/**
* @author :叙
*/
public class AVLtree {
static class Tree {
int height;
Tree leftTree;
Tree rightTree;
Tree parent;
int data;
//无参构造方法
Tree() {
}
Tree(int data) {
this.data = data;
//默认高度为1
this.height = 1;
}
}
/**
* 计算平衡因子
*
* @param tree
* @return
*/
public int countBF(Tree tree) {
if (tree == null || tree.leftTree == null && tree.rightTree == null) {
return 0;
}
if (tree.leftTree == null) {
return -tree.rightTree.height;
} else if (tree.rightTree == null) {
return tree.leftTree.height;
} else {
return tree.leftTree.height - tree.rightTree.height;
}
}
/**
* 计算高度
*
* @param tree
*/
public void countHeight(Tree tree) {
if (tree != null) {
if (tree.leftTree != null || tree.rightTree != null) {
//左右子树最高的高度，加一为当前节点高度
tree.height = Math.max(tree.rightTree == null ? 0 : tree.rightTree.height, tree.leftTree == null ? 0 : tree.leftTree.height) + 1;
} else {
tree.height = 1;
}
}
}
/**
* 右旋
* ● 旧根节点为新根节点的右子树
* ● 新根节点的右子树为旧根节点的左子树
*
* @param tree
*/
public void rightRotate(Tree tree) {
Tree oldTree = tree;
Tree newTree = tree.leftTree;
Tree parent = tree.parent;
if (parent != null) {
//确定旧根节点在父类的位置，放入新根节点
if (oldTree.parent.data > oldTree.data) {
parent.leftTree = newTree;
} else {
parent.rightTree = newTree;
}
}
//修改新根节点的父节点为旧根节点的父节点
newTree.parent = parent;
//新根节点的右子树为旧根节点的左子树
oldTree.leftTree = newTree.rightTree;
if (newTree.rightTree!=null){
//新根节点的右子树的父节点为旧根节点
newTree.rightTree.parent = oldTree;
}
//新根节点的右子树为旧根节点
newTree.rightTree = oldTree;
//修改旧根节点的父节点为新根节点
oldTree.parent = newTree;
//修改高度
countHeight(oldTree);
countHeight(newTree);
}
/**
* 左旋
* ● 旧根节点为新根节点的左子树
* ● 新根节点的左子树为旧根节点的右子树
*
* @param tree
*/
public void leftRotate(Tree tree) {
Tree oldTree = tree;
Tree newTree = tree.rightTree;
Tree parent = tree.parent;
if (parent != null) {
//确定旧根节点在父类的位置，放入新根节点
if (oldTree.parent.data > oldTree.data) {
parent.leftTree = newTree;
} else {
parent.rightTree = newTree;
}
}
//修改新根节点的父节点为旧根节点的父节点
newTree.parent = parent;
//新根节点的左子树为旧根节点的右子树
oldTree.rightTree = newTree.leftTree;
if(newTree.leftTree!=null){
//新根节点的左子树的父节点为旧根节点
newTree.leftTree.parent = oldTree;
}
//修改新根节点的右子树的父节点为旧根节点
newTree.leftTree = oldTree;
//修改旧根节点的父节点为新根节点
oldTree.parent = newTree;
//修改高度
countHeight(oldTree);
countHeight(newTree);
}
private Tree root;
/**
* 插入节点（递归）
* @param root
* @param data
*/
public void insert(Tree root, int data) {
//小于根节点，则插入到左边
if (data < root.data) {
if (root.leftTree != null) {
insert(root.leftTree, data);
} else {
root.leftTree = new Tree(data);
root.leftTree.parent = root;
}
} else {
//大于根节点，则插入到右边
if (root.rightTree != null) {
insert(root.rightTree, data);
} else {
root.rightTree = new Tree(data);
root.rightTree.parent = root;
}
}
//左子树高则右旋
if(countBF(root) == 2){
//左孩子节点的右子树高则先左旋
if(countBF(root.leftTree) == -1){
leftRotate(root.leftTree);
}
rightRotate(root);
}
//右子树高则左旋
if(countBF(root) == -2){
//右孩子节点的左子树高则先右旋
if(countBF(root.rightTree) == 1){
rightRotate(root.rightTree);
}
leftRotate(root);
}
//调整之后重新计算节点的高度
countHeight(root);
}
/**
* 插入
* @param data
*/
public Tree insert(int data){
//初始数据
if(root ==null){
root = new Tree(data);
}else{
//刷新root,使root始终为根节点
while(root.parent!=null){
root = root.parent;
}
insert(root,data);
}
return root;
}
/**
* 层次遍历树
* @param tree
*/
public void showTree(Tree tree){
List<List<String>> res = new ArrayList<>();
Queue<Tree> queue = new LinkedList<>();
queue.add(tree);
while (!queue.isEmpty()){
int count = queue.size();
List<String> list = new ArrayList<>();
while (count > 0) {
Tree node = queue.poll();
list.add("{当前节点："+node.data+"，父节点："+(node.parent==null?null:node.parent.data)+"}");
if(node!=null && node.leftTree!=null){
queue.add(node.leftTree);
}
if(node!=null && node.rightTree!=null){
queue.add(node.rightTree);
}
count--;
}
res.add(list);
}
for (List<String> re : res) {
System.out.println(re);
}
}
/**
* 删除
* 1、删除节点为叶子节点时，更新该节点的父节点高度，以及往上所有父节点高度；
* 2、删除节点只有左子树或者右子树时，该删除节点下的左子树或右子树接上，并且更新原删除节点的父节点高度；
* 3、删除节点有左子树和右子树时，将该删除节点替换为删除节点的直接后继节点，并且回调本方法删除该后继节点；
* 4、删除后，需要从根节点往下，依次计算平衡因子，判断是否失衡，并调整
*/
public Tree delete(Tree root,int key){
//找到需要删除的节点
Tree current = find(root,key);
Tree parent = current==null?null:current.parent;
if(current!=null){
//删除节点的左子树不为空
if(current.leftTree != null && current.rightTree != null){
//查询待删除节点的直接后继节点
Tree successorNode = getSuccessorNode(current);
//保存节点数据，便于后面的替换
int data = successorNode.data;
//删除该后继节点
delete(root,successorNode.data);
//替换节点
current.data = data;
}else if(current.leftTree != null || current.rightTree != null){
//删除含有左子树或者右子树的节点,将删除节点的父节点直接连接删除节点的左子树或者右子树
if(current.leftTree!=null){
current.leftTree.parent = parent;
}else{
current.rightTree.parent = parent;
}
if(parent!=null){
if(parent.data>current.data){
parent.leftTree = current.leftTree != null?current.leftTree:current.rightTree;
}else{
parent.rightTree = current.leftTree != null?current.leftTree:current.rightTree;
}
//更新高度
updateHeight(parent);
}else{
//删除节点为根节点，直接将根节点替换为下一个节点
if(current.leftTree!=null){
root = current.leftTree;
}else{
root = current.rightTree;
}
}
}else{
//删除叶子节点
if(parent==null){
//根节点，直接将树置空
root = null;
}else{
//删除叶子节点,直接置空
if(parent.data>current.data){
parent.leftTree = null;
}else{
parent.rightTree = null;
}
//更新高度
updateHeight(parent);
}
}
return update(root,key);
}
return null;
}
/**
* 从tree节点开始，一直往上更新节点高度
* @param tree
*/
public void updateHeight(Tree tree){
Tree parent = tree;
while(parent!=null){
//修改父节点高度
countHeight(parent);
parent = parent.parent;
}
}
/**
* 查找节点
* @param root
* @param key
* @return
*/
public Tree find(Tree root,int key){
if(root == null){
return null;
}
Tree current = root;
while(current.data!=key){
if(current.data>key){
current = current.leftTree;
}else{
current = current.rightTree;
}
if(current==null){
break;
}
}
return current;
}
/**
* 获取tree的后继节点
* @param tree
* @return
*/
public Tree getSuccessorNode(Tree tree){
Tree current = tree==null?null:tree.rightTree;
if(current==null){
return null;
}
while(current.leftTree != null){
current = current.leftTree;
}
return current;
}
/**
* 递归调整二叉树
* @param root
* @param key
*/
public void updateTree(Tree root,int key){
Tree current = root;
//左子树高则右旋
if(countBF(current) == 2){
//左孩子节点的右子树高则先左旋
if(countBF(current.leftTree) == -1){
leftRotate(current.leftTree);
}
rightRotate(current);
}
//右子树高则左旋
if(countBF(current) == -2){
//右孩子节点的左子树高则先右旋
if(countBF(current.rightTree) == 1){
rightRotate(current.rightTree);
}
leftRotate(current);
}
//调整之后重新计算节点的高度
countHeight(root);
if(key<current.data){
if(current.leftTree == null){
}else{
updateTree(current.leftTree,key);
}
}else{
if(current.rightTree == null){
}else{
updateTree(current.rightTree,key);
}
}
}
/**
* 调整二叉树为平衡二叉树
* @param tree
* @param data 删除节点
* @return
*/
public Tree update(Tree tree,int data){
//初始数据
if(tree ==null){
tree = new Tree(data);
}else{
//刷新tree,使tree始终为根节点
while(tree.parent!=null){
tree = tree.parent;
}
updateTree(tree,data);
}
//刷新tree，使tree为根节点
while(tree.parent!=null){
tree = tree.parent;
}
return tree;
}
/**
* 测试
* @param args
*/
public static void main(String[] args) {
AVLtree avLtree = new AVLtree();
avLtree.insert(3);
avLtree.insert(2);
avLtree.insert(1);
avLtree.insert(4);
avLtree.insert(5);
avLtree.insert(6);
avLtree.insert(7);
avLtree.insert(10);
avLtree.insert(9);
Tree tree = avLtree.insert(8);
avLtree.showTree(tree);
System.out.println("-----------------");
Tree tree5 = avLtree.delete(tree,5);
avLtree.showTree(tree5);
System.out.println("-----------------");
Tree tree6 = avLtree.delete(tree,6);
avLtree.showTree(tree6);
}
}结果：
五、红黑树(R-B Tree)
介绍：
红黑树，其节点分为两类，一类被标记为红色，另一类被标记为黑色；红黑树是一棵不完整的平衡二叉查找树树，
性质：
- 根节点是黑色
- 叶子节点不存储数据，并且是黑色
- 任何相邻的节点不能同时为红色，必须使用黑色节点隔开
- 对于单个节点，该节点到叶子节点的所有路径中都包含相同数目的黑色节点
旋转：
- 左旋
-
- 旧根节点的右子树为新根节点的左子树
- 新根节点的左子树为旧根节点
- 交换新根节点和旧根节点的颜色，新黑旧红
- 右旋
-
- 旧根节点的左子树为新根节点的右子树
- 新根节点的右子树为旧根节点
- 交换新根节点和旧根节点的颜色，新黑旧红
红黑树的插入步骤：
- 生成二叉查找树
- 令插入点为红色
- 判断是否需要旋转调整，以及如何调整
判断情况如下：
情况一：插入点为根节点，违反了性质1，直接令其为黑色
情况二：插入点的父节点为红色，违反了性质3，需要进行调整
父节点为红色的情况需要再细分为以下几种：
父节点为红色，父节点的兄弟节点为黑色，插入点位于父节点的左子树，如下图，需要先右旋，然后左旋，并交换祖父节点和插入节点的颜色
父节点为红色，父节点的兄弟节点为黑色，插入点位于父节点的右子树，如下图，需要先左旋，然后右旋，并交换祖父节点和插入节点的颜色
父节点为红色，父节点的兄弟节点也为红色，如下图，需要把父节点和父节点的兄弟节点全变为黑色，并将祖父节点变为红色，再将祖父节点当作插入点，递归重复判断是否需要调整（PS：若最后把根节点变成了红色，直接将根节点改成黑色即可，如下图第三张）
例子：假设需要顺序插入{2,4,3,5,6,8,7,9}，生成一棵红黑树，以下列出了推导过程图。
红黑树插入实现(Java)
package com.examply;
import java.util.*;
/**
* 红黑树
*/
public class RBTree {
static class RBNode{
int data;
RBNode leftNode;
RBNode rightNode;
RBNode parent;
int color;//颜色，0红色1黑色
//无参构造方法
RBNode() {
}
RBNode(int data) {
this.data = data;
//默认颜色为红色
this.color = 0;
}
}
//红色
private static final int RED_NODE = 0;
//黑色
private static final int BLACK_NODE = 1;
/**
* 左旋
* @param node
*/
public void leftRotate(RBNode node){
if(node==null){
return;
}
RBNode oldNode = node.parent;
RBNode parent = oldNode.parent;
RBNode newNode = node;
//新根节点的父节点为旧根节点的父节点
newNode.parent = parent;
if(parent!=null){
if(parent.data<oldNode.data){
parent.rightNode = newNode;
}else{
parent.leftNode = newNode;
}
}
if(newNode.leftNode!=null){
//新根节点的左子树的父节点为旧根节点
newNode.leftNode.parent = oldNode;
}
//旧根节点的右子树为新根节点的左子树
oldNode.rightNode = newNode.leftNode;
//新根节点的左子树为旧根节点
newNode.leftNode = oldNode;
//旧根节点的父节点为新根节点
oldNode.parent = newNode;
}
/**
* 右旋
* @param node
*/
public void rightRotate(RBNode node){
if(node==null){
return;
}
RBNode oldNode = node.parent;
RBNode parent = oldNode.parent;
RBNode newNode = node;
//新根节点的父节点为旧根节点的父节点
newNode.parent = parent;
if(parent!=null){
if(parent.data<oldNode.data){
parent.rightNode = newNode;
}else{
parent.leftNode = newNode;
}
}
if(newNode.rightNode!=null){
//新根节点的右子树的父节点为旧根节点
newNode.rightNode.parent = oldNode;
}
//旧根节点的左子树为新根节点的右子树
oldNode.leftNode = newNode.rightNode;
//新根节点的右子树为旧根节点
newNode.rightNode = oldNode;
//旧根节点的父节点为新根节点
oldNode.parent = newNode;
}
/**
* 插入数据
* @param root
* @param data
*/
public void insert(RBNode root,int data){
if(root==null){
return;
}
RBNode current = root;
//插入数据
if(root.data>data){
if(root.leftNode!=null){
current = root.leftNode;
insert(current,data);
return;
}else{
root.leftNode = new RBNode(data);
root.leftNode.parent = root;
current = root.leftNode;
}
}else{
if(root.rightNode!=null){
current = root.rightNode;
insert(current,data);
return;
}else{
root.rightNode = new RBNode(data);
root.rightNode.parent = root;
current = root.rightNode;
}
}
fixRBTree(current);
}
/**
* 调整红黑树
* @param current
*/
public void fixRBTree(RBNode current){
//根节点，直接变黑色
if(current.parent==null){
current.color = BLACK_NODE;
}else{
RBNode parent = current.parent;
//判断父节点为红色
if(parent.color == RED_NODE){
//判断插入点位于左子树还是右子树
if(current.data>parent.data){
//判断父节点的兄弟节点位置
if(parent.parent.data<parent.data){
//RR型
//判断父节点的兄弟节点是否为红色
if(parent.parent.leftNode!=null && parent.parent.leftNode.color==RED_NODE){
//令父节点的兄弟节点为黑色
parent.parent.leftNode.color = BLACK_NODE;
//令父节点为黑色
parent.color = BLACK_NODE;
//令祖父节点为红色
parent.parent.color = RED_NODE;
//递归祖父节点
fixRBTree(parent.parent);
}else{
//左旋
leftRotate(current.parent);
//新根节点为黑色
current.parent.color = BLACK_NODE;
//旧根节点为红色
if(current.parent.leftNode!=null){
current.parent.leftNode.color = RED_NODE;
}
}
}else{
//LR型
if(parent.parent.rightNode!=null && parent.parent.rightNode.color==RED_NODE){
//令父节点的兄弟节点为黑色
parent.parent.rightNode.color = BLACK_NODE;
//令父节点为黑色
parent.color = BLACK_NODE;
//令祖父节点为红色
parent.parent.color = RED_NODE;
//递归祖父节点
fixRBTree(parent.parent);
}else{
//左旋
leftRotate(current);
//右旋
rightRotate(current);
//新根节点为黑色
current.color = BLACK_NODE;
//旧根节点为红色
current.rightNode.color = RED_NODE;
}
}
}else{
//RL型
if(parent.parent.data<parent.data){
if(parent.parent.leftNode!=null && parent.parent.leftNode.color==RED_NODE){
//令父节点的兄弟节点为黑色
parent.parent.leftNode.color = BLACK_NODE;
//令父节点为黑色
parent.color = BLACK_NODE;
//令祖父节点为红色
parent.parent.color = RED_NODE;
//递归祖父节点
fixRBTree(parent.parent);
}else{
//右旋
rightRotate(current);
//左旋
leftRotate(current);
//新根节点为黑色
current.color = BLACK_NODE;
//旧根节点为红色
current.leftNode.color = RED_NODE;
}
}else{
//LL型
if(parent.parent.rightNode!=null && parent.parent.rightNode.color==RED_NODE){
//令父节点的兄弟节点为黑色
parent.parent.rightNode.color = BLACK_NODE;
//令父节点为黑色
parent.color = BLACK_NODE;
//令祖父节点为红色
parent.parent.color = RED_NODE;
//递归祖父节点
fixRBTree(parent.parent);
}else{
//右旋
rightRotate(current.parent);
//新根节点为黑色
current.parent.color = BLACK_NODE;
//旧根节点为红色
current.parent.rightNode.color = RED_NODE;
}
}
}
}
}
}
private RBNode root;
public RBNode insert(int data){
//初始数据
if(root ==null){
root = new RBNode(data);
root.color = BLACK_NODE;
}else{
//刷新root,使root始终为根节点
while(root.parent!=null){
root = root.parent;
}
insert(root,data);
}
return root;
}
/**
* 层次遍历树
* @param tree
*/
public void showTree(RBNode tree){
//使tree指向根节点
while(tree.parent!=null){
tree = tree.parent;
}
List<List<String>> res = new ArrayList<>();
Queue<RBNode> queue = new LinkedList<>();
queue.add(tree);
while (!queue.isEmpty()){
int count = queue.size();
List<String> list = new ArrayList<>();
while (count > 0) {
RBNode node = queue.poll();
list.add("{当前节点："+node.data+"颜色为："+(node.color==0?"红色":"黑色")+"，父节点："+(node.parent==null?null:node.parent.data)+"}");
if(node!=null && node.leftNode!=null){
queue.add(node.leftNode);
}
if(node!=null && node.rightNode!=null){
queue.add(node.rightNode);
}
count--;
}
res.add(list);
}
for (List<String> re : res) {
System.out.println(re);
}
}
public static void main(String[] args) {
RBTree tree = new RBTree();
tree.insert(2);
tree.insert(4);
tree.insert(3);
tree.insert(5);
tree.insert(6);
tree.insert(8);
tree.insert(7);
RBNode root = tree.insert(9);
tree.showTree(root);
}
}结果：
以上就是全部内容，不足之处，请多指教
扫一扫
3234
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
