红黑树的插入和创建

最新推荐文章于 2020-07-30 23:46:42 发布
最新推荐文章于 2020-07-30 23:46:42 发布
阅读量90 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36368627/article/details/82465655
版权 
红黑树的插入和创建
import java.util.Random;

public class RBTree<T extends Comparable> {

    private RBTreeNode<T> root;
    private static final boolean red=true;
    private static final boolean black=false;

    public void creatRBT(T[] arr)
    {
        for(int i=0;i<arr.length;i++)
        {
            this.insertRBT(arr[i]);
        }
    }

    public void insertRBT(T key)
    {
        RBTreeNode<T> insertNode=new RBTreeNode<>();
        insertNode.setKey(key);
        insertNode.setColor(red);
        this.insertRBT(insertNode,root,null);
    }
    public static boolean fixed=true;
    public boolean insertRBT(RBTreeNode<T> insertNode,RBTreeNode<T> tempNode,RBTreeNode<T> preNode)
    {       
        if(tempNode==null)
        {
            if(preNode==null) {insertNode.setColor(black);root=insertNode;}
            else if(preNode.getKey().compareTo(insertNode.getKey())>0) {preNode.setLeftchild(insertNode);insertNode.setParent(preNode);}
            else {preNode.setRightchild(insertNode); insertNode.setParent(preNode);}
            fixed=false;
        }
        else {
            if(tempNode.getKey().equals(insertNode.getKey())) { return false;}
            if(tempNode.getKey().compareTo(insertNode.getKey())>0)
            {
                if(!this.insertRBT(insertNode, tempNode.getLeftchild(), tempNode)) return false;
                if(!fixed) {
                    this.fixRBT(insertNode);
                    fixed=true;
                }
            }
            else {
                if(!this.insertRBT(insertNode, tempNode.getRightchild(), tempNode)) return false;
                if(!fixed) {
                    this.fixRBT(insertNode);
                    fixed=true;
                }
            }
        }
        return true;
    }
    public boolean fixRBT(RBTreeNode<T> targetNode)
    {   
        if(targetNode.getParent()!=null)
        {   
            RBTreeNode<T> parentNode=targetNode.getParent();
            if(parentNode.isColor())
            {   
                RBTreeNode<T> gparentNode=parentNode.getParent()!=null?parentNode.getParent():null;
                if(gparentNode!=null)
                {   
                    if(gparentNode.getLeftchild()!=null&&gparentNode.getLeftchild().equals(parentNode))
                    { 
                        RBTreeNode<T> broNode=gparentNode.getRightchild();
                        if(broNode==null||!broNode.isColor())
                        {   
                            if(parentNode.getLeftchild()!=null&&parentNode.getLeftchild().equals(targetNode))
                            {
                                parentNode.setColor(black);
                                gparentNode.setColor(red);
                                this.R_Rotate(gparentNode);
                                //fixed=true;
                                //break;
                            }
                            else
                            {
                                    targetNode.setColor(black);
                                    gparentNode.setColor(red);
                                    this.L_Rotate(parentNode);
                                    this.R_Rotate(gparentNode);
                                    //fixed=true;
                                    //break;
                            }
                        }
                        else {
                            parentNode.setColor(black);
                            broNode.setColor(black);
                            gparentNode.setColor(red);
                            targetNode=gparentNode;
                            this.fixRBT(targetNode);
                            return true;
                            //break;
                            //break;
                            }
                    }
                    else {
                        RBTreeNode<T> broNode=gparentNode.getLeftchild();
                        if(broNode==null||!broNode.isColor())
                        {   
                            if(parentNode.getRightchild()!=null&&parentNode.getRightchild().equals(targetNode))
                            {
                                parentNode.setColor(black);
                                  gparentNode.setColor(red);
                                  this.L_Rotate(gparentNode);
                                  //fixed=true;
                                 // break;
                            }
                            else
                            {
                                targetNode.setColor(black);
                                gparentNode.setColor(red);
                                this.R_Rotate(parentNode);
                                this.L_Rotate(gparentNode);
                                //fixed=true;
                                //break;
                            }
                        }
                        else {
                            parentNode.setColor(black);
                            broNode.setColor(black);
                            gparentNode.setColor(red);
                            targetNode=gparentNode;
                            this.fixRBT(targetNode);
                            return true;
                            //break;
                            //break;
                        }
                    }                   
            }               
        }           
    }   
            this.root.setColor(black);
            return true;
}
    public void R_Rotate(RBTreeNode<T> targetNode)
    {
        RBTreeNode<T> lc=targetNode.getLeftchild();
        RBTreeNode<T> parentNode=targetNode.getParent();
        targetNode.setLeftchild(lc.getRightchild());
        if(lc.getRightchild()!=null) lc.getRightchild(). setParent(targetNode);
        lc.setRightchild(targetNode);
        targetNode.setParent(lc);
        targetNode=lc;
        if(parentNode==null) {targetNode.setParent(null); root=targetNode;}
        else if(parentNode.getKey().compareTo(targetNode.getKey())>0) {targetNode.setParent(parentNode); parentNode.setLeftchild(targetNode);}
        else {targetNode.setParent(parentNode); parentNode.setRightchild(targetNode);}
    }
    public void L_Rotate(RBTreeNode<T> targetNode)
    {
        RBTreeNode<T> rc=targetNode.getRightchild();
        RBTreeNode<T> parentNode=targetNode.getParent();
        targetNode.setRightchild(rc.getLeftchild());
        if(rc.getLeftchild()!=null) rc.getLeftchild().setParent(targetNode);
        rc.setLeftchild(targetNode);
        targetNode.setParent(rc);
        targetNode=rc;
        if(parentNode==null) {targetNode.setParent(null); root=targetNode;}
        else if(parentNode.getKey().compareTo(targetNode.getKey())>0) {targetNode.setParent(parentNode);parentNode.setLeftchild(targetNode);}
        else {targetNode.setParent(parentNode); parentNode.setRightchild(targetNode);}
    }
    //中序遍历
    public void inOrderVisitRBT()
    {   
        this.inOrderVisitRBT(root);
        System.out.println();
    }
    private void inOrderVisitRBT(RBTreeNode tempNode)
    {   

        if(tempNode!=null)
        {   
            //System.out.println("111");
            this.inOrderVisitRBT(tempNode.getLeftchild());
            System.out.print(tempNode.getKey()+" ");        
            this.inOrderVisitRBT(tempNode.getRightchild()); 
        }   
    }
    //先序遍历
    public void preVisitRBT()
    {
        this.preVisitRBT(root);
        System.out.println();
    }
    public void preVisitRBT(RBTreeNode tempNode)
    {
        if(tempNode!=null)
        {
            System.out.print(tempNode.getKey()+" "+tempNode.isColor()+" ");
            this.preVisitRBT(tempNode.getLeftchild());
            this.preVisitRBT(tempNode.getRightchild());
        }
    }
      public static void main(String[] args)
       {
           Integer[] arr=new Integer[10]; 
          for(int i=0;i<10;i++)
           {
               arr[i]=new Random().nextInt(100);
               System.out.println("arr["+i+"]="+arr[i]);
           }
           RBTree<Integer> rbt=new RBTree<>();
           rbt.creatRBT(arr);
           rbt.inOrderVisitRBT();
           rbt.preVisitRBT();
       }
}

class RBTreeNode<T extends Comparable>
{
    private T key;
    private RBTreeNode<T> leftchild,rightchild,parent;
    private boolean color;//false为黑，true为红
    public T getKey() {
        return key;
    }
    public void setKey(T key) {
        this.key = key;
    }
    public RBTreeNode<T> getLeftchild() {
        return leftchild;
    }
    public void setLeftchild(RBTreeNode<T> leftchild) {
        this.leftchild = leftchild;
    }
    public RBTreeNode<T> getRightchild() {
        return rightchild;
    }
    public void setRightchild(RBTreeNode<T> rightchild) {
        this.rightchild = rightchild;
    }
    public RBTreeNode<T> getParent() {
        return parent;
    }
    public void setParent(RBTreeNode<T> parent) {
        this.parent = parent;
    }
    public boolean isColor() {
        return color;
    }
    public void setColor(boolean color) {
        this.color = color;
    }

}
jgqwork
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
红黑树的插入、创建和删除
maqian5的博客
08-14 1144
文章目录1.红黑树介绍2.红黑树的旋转3.红黑树的插入4.红黑树的删除5.参考 1.红黑树介绍    二叉搜索树在最好情况下的时间复杂度是O（logn）O（log n）O（logn），但是当插入元素是有序的时候，二叉搜索树就变成了一个链表，在这种情况下，时间复杂度为O(n)O(n)O(n)。    红黑树就是针对这一情形进行改进。红黑树本质上是一种二叉搜索树，但它在二叉搜索树的基础上额外添加了一个...
红黑树的插入
qq_34605257的博客
06-18 265
推荐一个学习红黑树的工具网址，可以动态生成红黑树，一步一步观察插入和删除的步骤。 红黑树动态生成网站：https://www.cs.usfca.edu/~galles/visualization/RedBlack.html 红黑树的5大特性 节点要么红色要么黑色 根节点一定是黑色 红色节点的子节点一定是黑色（NULL节点看成黑色） 没有连续的两个红色节点（但可以有连续的黑色节点） 从任何一个节点出发到NULL叶子节点的路径包含的黑色节点数量相同（红黑树的叶子节点定义跟往常的不一样，指的NULL节点） 与
C++数据结构：红黑树的原理以及实现
Outtch_的博客
07-30 799
前言 之前我们学习了AVL树，说AVL树是具有特殊性质的二叉搜索树，而红黑树这种数据结构也是有着特殊性质的二叉搜索树，
红黑树
weixin_44856859的博客
07-20 138
红黑树（Red Black Tree） 定义：一种自二叉树，典型用途是实现关联数组， 红黑树与AvL树类似，都是在进行插入和删除时进行特定操作 AVL树在进行插入和删除时会要保持树的平衡会采取大量的旋转操作，在碎渣大量的数据插入进行旋转会是的插入效率大大降低，引入红黑树会大大减少旋转次数，红黑树可在O(logn)时间内做查找，插入和删除，这里边的n为树中的元素。 红黑树的性质(红黑规则) （...
红黑树插入时的自平衡
12-21
红黑树是一种自平衡二叉查找树，它的主要目的是在执行插入和删除操作时能快速地重新平衡，确保查找效率。红黑树的特性如下： 1. 每个节点要么是红色，要么是黑色。 2. 根节点必须是黑色。 3. 任何两个相邻的红色...
链表和红黑树测试代码
10-09
3. 测试代码：这部分可能演示了如何使用这些数据结构，如何创建和操作链表和红黑树，以及如何将它们编译为库以便在其他项目中复用。 学习这部分内容有助于深入理解Linux内核的工作原理，特别是涉及到内存管理和文件...
win32 红黑树模拟器
12-19
在Win32环境下，开发一个红黑树模拟器是为了帮助程序员更好地理解和调试红黑树算法。这个模拟器允许用户观察树在插入、删除和查找操作过程中的动态变化。 红黑树的主要特性包括： 1. 每个节点都带有颜色属性，可以...
PRBtree.rar_红黑树
09-21
2. **插入操作**：插入新节点时，首先进行标准的二叉查找树插入，然后通过旋转和重新着色来恢复红黑树的性质。可能包含`insertNode()`函数。 3. **删除操作**：删除节点相对复杂，可能涉及节点替换、颜色调整和旋转...
java中treemap和treeset实现红黑树
08-28
红黑树是一种自平衡的排序二叉树，它可以保证在插入、删除和搜索操作时都能维持平衡，从而确保搜索、插入和删除操作的效率。 TreeMap 是一个基于红黑树的排序Map实现，它可以根据键的自然顺序或定制的Comparator...
VB+ACCESS宾馆客房管理系统(系统+论文+封面).zip
08-16
计算机毕业设计资源包含（项目部署视频+源码+LW+开题报告等等），所有项目经过助教老师跑通，有问题可以私信博主解决，可以免费帮部署。
自密实混凝土的研究进展.doc
08-16
自密实混凝土的研究进展.doc
基于Andriod条码识别的商品价格查询软件APP设计与实现.docx
08-16
基于Andriod条码识别的商品价格查询软件APP设计与实现.docx
基于python的人脸控制俄罗斯方块小游戏
08-16
基于python的人脸控制俄罗斯方块小游戏
vb+access高校固定资产管理系统(论文+程序).zip
最新发布
08-16
计算机毕业设计资源包含（项目部署视频+源码+LW+开题报告等等），所有项目经过助教老师跑通，有问题可以私信博主解决，可以免费帮部署。
redis，一个使用ANSI C编写的开源、包含多种数据结构、支持网络、基于内存、可选持久性的键值对存储数
08-16
引言 在Web应用发展的初期，那时关系型数据库受到了较为广泛的关注和应用，原因是因为那时候Web站点基本上访问和并发不高、交互也较少。而在后来，随着访问量的提升，使用关系型数据库的Web站点多多少少都开始在性能上出现了一些瓶颈，而瓶颈的源头一般是在磁盘的I/O上。而随着互联网技术的进一步发展，各种类型的应用层出不穷，这导致在当今云计算、大数据盛行的时代，对性能有了更多的需求，主要体现在以下四个方面： 低延迟的读写速度：应用快速地反应能极大地提升用户的满意度 支撑海量的数据和流量：对于搜索这样大型应用而言，需要利用PB级别的数据和能应对百万级的流量 大规模集群的管理：系统管理员希望分布式应用能更简单的部署和管理 庞大运营成本的考量：IT部门希望在硬件成本、软件成本和人力成本能够有大幅度地降低 为了克服这一问题，NoSQL应运而生，它同时具备了高性能、可扩展性强、高可用等优点，受到广泛开发人员和仓库管理人员的青睐。 Redis是什么 Redis是现在最受欢迎的NoSQL数据库之一，Redis是一个使用ANSI C编写的开源、包含多种数据结构、支持网络、基于内存、可选持久性的键值对存储数
51单片机（STC89C2）学习笔记2-4独立按键控制LED移位
08-16
51单片机（STC89C2）学习笔记2-4独立按键控制LED移位C语言代码
施耐德ATVA71变频器编程手册
08-16
施耐德ATVA71变频器编程手册
基于jsoncpp1.9.5源码修改，解决中文汉字乱码和小数点精度丢失问题
08-16
jsoncpp1.9.5源码修改使用VS2022生成静态lib文件，包含2个项目工程一个静态编译方法和一个示例源码，生成了x86 x64的调试版和发布版，静态编译工程也可以自己再次编译，源码可以按需自行修改 {"base_para":{"chann_num":1,"height":460,"width":680},"para":[{"flag":0,"name":"卧槽","th":0.456},{"flag":1,"name":"牛上天","th":0.8537}],"project":"哈哈，你好"}
基于Android任务管理器APP设计与实现.docx
08-16
基于Android任务管理器APP设计与实现.docx
用c语言实现红黑树插入的代码
05-27
红黑树是一种自平衡二叉搜索树，它的插入操作相对比较复杂。下面是一个简单的C语言实现红黑树插入的示例代码，供你参考： ```c #include <stdio.h> #include <stdlib.h> // 红黑树节点 typedef struct TreeNode { int value; // 节点值 int color; // 颜色，0表示黑色，1表示红色 struct TreeNode *parent; // 父节点指针 struct TreeNode *left; // 左子节点指针 struct TreeNode *right; // 右子节点指针 } TreeNode; // 创建一个红黑树节点 TreeNode* createTreeNode(int value, int color, TreeNode *parent, TreeNode *left, TreeNode *right) { TreeNode *node = (TreeNode*)malloc(sizeof(TreeNode)); node->value = value; node->color = color; node->parent = parent; node->left = left; node->right = right; return node; } // 获取节点的颜色 int getColor(TreeNode *node) { if (node == NULL) { return 0; // 空节点为黑色 } else { return node->color; } } // 左旋操作 void leftRotate(TreeNode **root, TreeNode *node) { TreeNode *rightChild = node->right; node->right = rightChild->left; if (rightChild->left != NULL) { rightChild->left->parent = node; } rightChild->parent = node->parent; if (node->parent == NULL) { *root = rightChild; } else if (node == node->parent->left) { node->parent->left = rightChild; } else { node->parent->right = rightChild; } rightChild->left = node; node->parent = rightChild; } // 右旋操作 void rightRotate(TreeNode **root, TreeNode *node) { TreeNode *leftChild = node->left; node->left = leftChild->right; if (leftChild->right != NULL) { leftChild->right->parent = node; } leftChild->parent = node->parent; if (node->parent == NULL) { *root = leftChild; } else if (node == node->parent->left) { node->parent->left = leftChild; } else { node->parent->right = leftChild; } leftChild->right = node; node->parent = leftChild; } // 插入操作 void insert(TreeNode **root, int value) { // 创建一个新节点，并初始化为红色 TreeNode *node = createTreeNode(value, 1, NULL, NULL, NULL); // 执行BST插入操作 TreeNode *parent = NULL; TreeNode *current = *root; while (current != NULL) { parent = current; if (value < current->value) { current = current->left; } else { current = current->right; } } node->parent = parent; if (parent == NULL) { *root = node; } else if (value < parent->value) { parent->left = node; } else { parent->right = node; } // 颜色修正 while (getColor(node->parent) == 1) { if (node->parent == node->parent->parent->left) { TreeNode *uncle = node->parent->parent->right; if (getColor(uncle) == 1) { node->parent->color = 0; uncle->color = 0; node->parent->parent->color = 1; node = node->parent->parent; } else { if (node == node->parent->right) { node = node->parent; leftRotate(root, node); } node->parent->color = 0; node->parent->parent->color = 1; rightRotate(root, node->parent->parent); } } else { TreeNode *uncle = node->parent->parent->left; if (getColor(uncle) == 1) { node->parent->color = 0; uncle->color = 0; node->parent->parent->color = 1; node = node->parent->parent; } else { if (node == node->parent->left) { node = node->parent; rightRotate(root, node); } node->parent->color = 0; node->parent->parent->color = 1; leftRotate(root, node->parent->parent); } } if (node == *root) { break; } } (*root)->color = 0; } // 中序遍历输出红黑树 void inorderTraversal(TreeNode *node) { if (node == NULL) { return; } inorderTraversal(node->left); printf("%d(%d) ", node->value, node->color); inorderTraversal(node->right); } int main() { TreeNode *root = NULL; // 插入节点 insert(&root, 10); insert(&root, 20); insert(&root, 30); insert(&root, 15); insert(&root, 18); insert(&root, 25); insert(&root, 40); insert(&root, 12); insert(&root, 11); // 输出红黑树 printf("红黑树："); inorderTraversal(root); return 0; } ``` 在上面的代码中，我们首先定义了一个红黑树节点结构体，包含节点值、颜色、父节点指针、左子节点指针和右子节点指针等成员。然后，我们实现了创建节点、获取节点颜色、左旋和右旋等操作函数。最后，我们实现了插入操作和输出红黑树的函数，并在main函数中进行了测试。 需要注意的是，红黑树的插入操作相对比较复杂，需要进行颜色修正等操作，代码可能比较难理解。如果有不理解的地方，可以多看一下代码，或者参考一些其他资料。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值