红黑树容器实现（带迭代器）

最新推荐文章于 2022-11-26 10:00:00 发布
原创 最新推荐文章于 2022-11-26 10:00:00 发布 · 1.7k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种自实现的红黑树容器，该容器基于红黑树结构，并通过迭代器实现容器的基本功能。文章详细解释了红黑树节点的插入、删除及修复过程，并提供了一个简单的测试案例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

上一篇文章是纯粹地实现了红黑树，但是在STL中，红黑树容器是需要迭代器实现的。故将上一篇文章改进后实现红黑树容器。

本人实现的红黑树容器是底层红黑树结构是依据算法导论中设计的包含普通节点和空节点。不同于STL中的红黑树，其迭代器故也

有点不一样

//my_rb_tree.h

#ifndef MY_RB_TREE_H_INCLUDED
#define MY_RB_TREE_H_INCLUDED

#include"iterator_rb_tree.h"
#include"simple_allocator.h"

namespace juine
{
    //红黑树
    /*
    **红黑树容器中树节点存放的对象是Value，但是比较的对象，用来决定树的结构的则是Key，
    函数对象KeyOfvalue这是Value对象向Key对象的转化.
    这样红黑树容器与红黑树地区别就在于：
    在insert和delete需找对象进行比较的时候，我们得到了Value对象，要将其转化为Key,然后在进行比较
    例如以前是这样写的：
      if(temp->data<value)  //节点所指值小于值value
      要改成如下：
      if(key_compare(key(temp)),KeyOfValue()(value) )
      key_compare:为比较函数
      key：将所指节点值转化为key类型
      KeyOfValue；将Value值转化为Key类型

    */

    template<class Key,class Value,class KeyOfValue,class Compare,class Alloc=my_alloc>
    class RB_Tree
    {
    public:
        typedef Key key_type;
        typedef Value value_type;
    protected:

        RB_Node<Value>* root;   //红黑树的根节点
        RB_Node<Value>* nullNode;  //空节点，黑色的
        size_t node_num;
        Compare key_compare;   //定义一个比较函数对象


        typedef simple_allocator<RB_Node<Value>,Alloc> RB_Node_Container;

        //插入完成后要记得修复，使其满足红黑树的性质
        //插入时中的三种情况
        void InsertFixUp(RB_Node<Value> *node)
        {
            while(node->parent->RB_COLOR==RED)
            {
                //插入节点为父节点的左孩子
                if(node->parent->left==node)
                {
                    RB_Node<Value> *uncle=node->parent->parent->right;
                    if(uncle->RB_COLOR==RED)   //case 1
                    {
                        node->parent->RB_COLOR=BLACK;
                        uncle->RB_COLOR=BLACK;
                        node=node->parent->parent;
                        node->RB_COLOR=RED;
                    }
                    else
                    {
                        if(node->parent==node->parent->parent->right)    //case 2
                        {
                            node=node->parent;
                            right_rotate(node);
                           // goto double_left_rotate;
                        }
                        //case2结束以后直接进入case3，或者直接进入case3
                       // double_right_rotate:
                        else{
                            node->parent->RB_COLOR=BLACK;
                            node->parent->parent->RB_COLOR=RED;
                            right_rotate(node->parent->parent);
                        }
                    }

                }
                //当节点为为父节点的右孩子
                else
                {
                    RB_Node<Value> *uncle=node->parent->parent->left;
                    if(uncle->RB_COLOR==RED)   //case 1
                    {
                        node->parent->RB_COLOR=BLACK;
                        uncle->RB_COLOR=BLACK;
                        node=node->parent->parent;
                        node->RB_COLOR=RED;
                    }
                    else
                    {
                        if(node->parent==node->parent->parent->left)    //case 2
                        {
                            node=node->parent;
                            left_rotate(node);
                           // goto double_right_rotate;
                        }
                        //case2结束以后直接进入case3，或者直接进入case3
                      //  double_left_rotate:
                        else{
                            node->parent->RB_COLOR=BLACK;
                            node->parent->parent->RB_COLOR=RED;
                            left_rotate(node->parent->parent);
                        }
                    }
                }
            }
            if(node==root)
                node->RB_COLOR=BLACK;
        }

        //左旋转
        void left_rotate(RB_Node<Value> *node)
        {
            RB_Node<Value> *temp=node->right;
            temp->parent=node->parent;
            if(node->parent==nullNode)
                root=temp;
            else
            {
                if(node==node->parent->left)
                    node->parent->left=temp;
                else
                    node->parent->right=temp;
            }
            node->right=temp->left;
            if(temp->left!=nullNode)
                temp->left->parent=node;
            node->parent=temp;
            temp->left=node;
        }
        //右旋转
        void right_rotate(RB_Node<Value> *node)
        {
            RB_Node<Value> *temp=node->left;
            temp->parent=node->parent;
            if(node==root) //等价于node->parent==NULL
                root=temp;
            else
            {
                if(node==node->parent->left)
                    node->parent->left=temp;
                else
                    node->parent->right=temp;
            }
            node->left=temp->right;
            if(temp->right!=nullNode)
                temp->right->parent=node;
            node->parent=temp;
            temp->right=node;

        }

        //找到值为value的节点
        RB_Node<Value>* find_node(Value value)
        {
            RB_Node<Value> *temp=root;
            while(temp!=nullNode)
            {
                if(key_compare(KeyOfValue()(value),key(temp)))
                    temp=temp->left;
                else if(key_compare(key(temp),KeyOfValue()(value)))
                    temp=temp->right;
                else
                    break;
            }
            return temp;
        }

        //该函数的功能是用来在删除节点时，如果节点存在左右孩子节点则找到应该替换的节点
        RB_Node<Value>* find_delete_node(RB_Node<Value> *node)
        {
            if(node->left==nullNode||node==nullNode)
                return nullNode;
            RB_Node<Value> *temp=node->left;
            while(temp->right!=nullNode)
                temp=temp->right;
            return temp;

        }

        void deleteFixUp(RB_Node<Value> *node)
        {
            RB_Node<Value> *temp=node;
            while(temp->RB_COLOR==BLACK&&temp!=root)
            {
                RB_Node<Value> *brother;
                //该节点为父节点的左节点
                if(temp==temp->parent->left)
                {
                    brother=temp->parent->right;
                    if(brother->RB_COLOR==RED)   //case 1
                    {
                        temp->parent->RB_COLOR=RED;
                        brother->RB_COLOR=BLACK;
                        //在旋转之后兄弟节点会发生变化，因此在旋转之前就将兄弟节点给换过来
                        brother=brother->left;
                        left_rotate(temp->parent);
                    }
                    //case 1结束后，会进入case2/case3/case4
                    if(brother->left->RB_COLOR==BLACK&&brother->right->RB_COLOR==BLACK)  //case2
                    {
                        brother->RB_COLOR=RED;
                        temp=temp->parent;
                    }
                    else
                    {
                        if(brother->right->RB_COLOR==BLACK)   //case 3
                        {
                            brother->RB_COLOR=RED;
                            brother->left->RB_COLOR=BLACK;
                            brother=brother->left;
                            right_rotate(brother->parent);
                        }
                        //进入case4情况
                        brother->RB_COLOR=temp->parent->RB_COLOR;
                        brother->right->RB_COLOR=temp->parent->RB_COLOR=BLACK;
                        left_rotate(temp->parent);
                        temp=root;
                    }
                }
                else  //该节点为父节点的右孩子
                {
                    brother=temp->parent->left;
                    if(brother->RB_COLOR==RED)   //case 1
                    {
                        temp->parent->RB_COLOR=RED;
                        brother->RB_COLOR=BLACK;
                        //在旋转之后兄弟节点会发生变化，因此在旋转之前就将兄弟节点给换过来
                        brother=brother->right;
                        right_rotate(temp->parent);
                    }
                    //case 1结束后，会进入case2/case3/case4
                    if(brother->left->RB_COLOR==BLACK&&brother->right->RB_COLOR==BLACK)  //case2
                    {
                        brother->RB_COLOR=RED;
                        temp=temp->parent;
                    }
                    else
                    {
                        if(brother->right->RB_COLOR==BLACK)   //case 3
                        {
                            brother->RB_COLOR=RED;
                            brother->left->RB_COLOR=BLACK;
                            brother=brother->left;
                            left_rotate(brother->parent);
                        }
                        //进入case4情况
                        brother->RB_COLOR=temp->parent->RB_COLOR;
                        brother->right->RB_COLOR=temp->parent->RB_COLOR=BLACK;
                        right_rotate(temp->parent);
                        temp=root;
                    }

                }
            }
            //最后退出来的时候记得将节点颜色变成黑色
            temp->RB_COLOR=BLACK;
        }

        RB_Node<Value>* alloc(COLOR color, Value value)
        {
            RB_Node<Value>* temp=RB_Node_Container::alloc(1);
            construct(temp,RB_Node<Value>(color,value));
            return temp;
        }


    public:
        //定义迭代器
        typedef Iterator_RB_Node<Value,Value&,Value*> iterator;
        typedef Iterator_RB_Node<Value,const Value&,const Value*> const_iterator;
        iterator begin()
        {
            RB_Node<Value>* temp=root;
            while(temp->left!=nullNode)
                temp=temp->left;
            return iterator(temp,nullNode);
        }
        iterator end(){  return iterator(nullNode,nullNode);}

        iterator minleft() {return begin();}
        iterator maxright()
        {
            RB_Node<Value>* temp=root;
            while(temp->right!=nullNode)
                temp=temp->right;
            return iterator(temp,nullNode);
        }

        //得到迭代器所指对象的key值
        key_type key(RB_Node<Value> *iter)
        {
            return KeyOfValue()(iter->data);
        }

        //构造函数初始化
        RB_Tree()
        {
            nullNode=alloc(BLACK,Value());
            root=nullNode;
            node_num=0;
            nullNode->left=nullNode->right=nullNode;
            nullNode->parent=root;

        }

        //红黑树的插入操作
        void insert_node(Value value)
        {
            node_num++;
            RB_Node<Value> *node=alloc(RED,value);
            node->left=node->right=node->parent=nullNode;
            if(root==nullNode)    //先把空树的情况处理掉
            {
                root=node;
                root->RB_COLOR=BLACK;
                return ;
            }
            RB_Node<Value> *temp=root;
            RB_Node<Value> *insert_parent;
            while(temp!=nullNode)
            {
                insert_parent=temp;
                // if(value<temp->data)
                if(key_compare(KeyOfValue()(value),key(temp)))
                    temp=temp->left;
                else
                    temp=temp->right;
            }
            // if(value<insert_parent->data)
            if(key_compare(KeyOfValue()(value),key(insert_parent)))
                insert_parent->left=node;
            else
                insert_parent->right=node;
            node->parent=insert_parent;
            //完成插入后的修复工作
            InsertFixUp(node);
        }

        //红黑树的删除操作
        void delete_node(Value value)
        {
            node_num--;
            RB_Node<Value> *node= find_node(value);
            RB_Node<Value> *delete_node,*delete_node_child;
            if(node->left==nullNode||node->right==nullNode)
                delete_node=node;
            else
                delete_node=find_delete_node(node);

            //如果删除点不是node，则应该将delete_node值复制过来
            if(delete_node!=node)
                node->data=delete_node->data;

            if(delete_node->left!=nullNode)
                delete_node_child=delete_node->left;
            else if(delete_node->right!=nullNode)
                delete_node_child=delete_node->right;
            else
                delete_node_child=nullNode;
            delete_node_child->parent=delete_node->parent;
            if(delete_node==root)
                root=delete_node_child;
            else
            {
                if(delete_node==delete_node->parent->left)
                    delete_node->parent->left=delete_node_child;
                else
                    delete_node->parent->right=delete_node_child;
            }
            if(delete_node->RB_COLOR==BLACK)
                deleteFixUp(delete_node_child);
            delete delete_node;
        }

        //打印节点
        void display()
        {
            display(root);
        }
        void display(RB_Node<Value> *node)
        {
            if(node->left!=nullNode)
                display(node->left);
            if(node!=nullNode)
                cout<<node->data<<" 颜色为："<<node->RB_COLOR<<endl;
            if(node->right!=nullNode)
                display(node->right);
        }

        size_t size(){  return node_num;}
    };

}
#endif // MY_RB_TREE_H_INCLUDED

#ifndef ITERATOR_RB_TREE_H_INCLUDED
#define ITERATOR_RB_TREE_H_INCLUDED

#include"my_iterator_base.h"
/*
**
iterator_rb_tree.h
红黑树地泛型容器地迭代器
与以往前面地容器构造方式不同，该容器采用双层架构，使其获得更加大的弹性
*/

namespace juine
{
    enum COLOR{RED,BLACK};

    template<class T>                //红黑树的节点信息
    struct RB_Node
    {
        typedef RB_Node* base_ptr;
        base_ptr left;
        base_ptr right;
        base_ptr parent;
        COLOR RB_COLOR;
        T data;
        RB_Node(COLOR _RB_COLOR=BLACK,T _data=0):RB_COLOR(_RB_COLOR),data(_data){}
    };

    //红黑树的正规迭代器(标准迭代器的写法)
    template<class Value,class Ref,class Ptr>
    struct Iterator_RB_Node
    {
        typedef Value value_type;
        typedef Ref reference;
        typedef Ptr pointer;
        typedef bidirectional_iterator_tag iterator_category;

        typedef Iterator_RB_Node<Value,Value&,Value*> iterator;
        typedef Iterator_RB_Node<Value,const Value&,const Value*> const_iterator;
        typedef Iterator_RB_Node<Value,Ref,Ptr> self;

        typedef RB_Node<Value>* link_type;

        link_type node;
        /*下面这个节点是我自己加的，因为我设计的红黑树中节点分为普通节点和空节点
        **所有节点的指针域都不会是NULL，我们都用空节点来代替，其颜色都是黑色
       因此，在迭代器执行++，--操作时，为了符合终止条件，故在创建迭代器时候，
       要讲迭代器所指向的红黑树中表达的空节点指针传过来，不然，迭代器中的循环终止
       条件无法判断。

        */
        link_type nullNode;

        //construct
        Iterator_RB_Node(){}
        Iterator_RB_Node(link_type x,link_type y){  node=x; nullNode=y;}
        Iterator_RB_Node(const iterator& it){  node=it.node; nullNode=it.nullNode;}
        self operator= (const iterator& it)
        {
            node=it.node;
            return *this;
        }
        bool operator!=(const self& it)
        {
            return node!=it.node;
        }

        //重载
        reference operator* () { return node->data;}
        link_type operator->  ()  {  return node;}

        self& operator++()
        {
            increment();
            return *this;
        }
        self operator++(int)
        {
            self iter=*this;
            ++*this;
            return iter;

        }
        self& operator--()
        {
            decrement();
            return *this;
        }
        self operator--(int)
        {
            self iter=*this;
            --*this;
            return iter;
        }
        void increment()   //指针++操作
        {
            //当孩子有右节点时，++为右子树的最大左孩子节点
            if(node->right!=nullNode)
            {
                node=node->right;
                while(node->left!=nullNode)
                    node=node->left;
            }
            else  //往父节点上寻找
            {
                link_type parents=node->parent;
                while(node==parents->right)  //为父节点右孩子时，继续往上找
                {
                    node=parents;
                    parents=parents->parent;
                }
                if(parents!=nullNode)
                    node=parents;
                else                       //找到根基点还没找到，则++应该指向空节点
                    node=nullNode;

            }
        }
        void decrement()
        {
            if(node->left!=nullNode)
            {
                node=node->left;
                while(node->right!=nullNode)
                    node=node->right;
            }
            else
            {
                RB_Node<Value>* parents=node->parent;
                while(parents->left==node)
                {
                    node=parents;
                    parents=parents->parent;
                }
                if(parents!=nullNode)
                    node=parents;
                else
                    node=nullNode;
            }

        }
    };



}



#endif // ITERATOR_RB_TREE_H_INCLUDED

以下是测试代码： 


#include<iostream>
#include"my_rb_tree.h"
//#include<stack>
using namespace std;
using namespace juine;
template<typename T>
struct identity
{
    const T& operator()(const T& x)
    {
        return x;
    }
};

template<class T>
struct comp
{
    bool operator()(T v1,T v2)
    {
        return v1>v2;
    }

};
int main()
{
    RB_Tree<int,int,identity<int>,comp<int> > q;
    int i;
    for(i=1;i<10;i++)
        q.insert_node(i);
    RB_Tree<int,int,identity<int>,comp<int> >::iterator iter=q.maxright();
        for(iter=q.maxright();iter!=q.end();iter--)
            cout<<*iter<<"  颜色为： "<<iter->RB_COLOR<<endl;
    for(i=1;i<10;i++)
    {
        q.delete_node(i);
        cout<<"删除"<<i<<"后："<<endl;
        RB_Tree<int,int,identity<int>,comp<int> >::iterator iter=q.maxright();
        for(iter=q.maxright();iter!=q.end();iter--)
            cout<<*iter<<"  颜色为： "<<iter->RB_COLOR<<endl;
    }

    return 0;
}














                

        

    

    
  



    



                



	

		

			

				
					
二叉树之红黑树迭代器

				
			

			

				

					dong18292000671的博客
				

				

					05-29
					
					578
					
				

			

		

		

			
				
红黑事的性质： 
1.每个节点不是红色就是黑色。 
2.根节点一定是黑色。 
3.没有两个连续的红色节点。 
4.每个叶子结点道根的路径上，黑色结点的个数都相等。 
5.每个叶子结点的空指针域都是黑色的。 
通过这些条件的设定，可以保证最长路径上结点的个数不会超过最短路径上节点个数的两倍。 
 
这是一种极限情况，但是这种情况不可能出现，因为正在插入每个节点时都需要调整。 
红黑树插入时要考虑的几种

			
		

	



                

            
              



	

		

			

				
					
红黑树/红黑树迭代器封装（C++）

					
最新发布

				
			

			

				

					m0_74830524的博客
				

				

					06-10
					
					1530
					
				

			

		

		

			
				
本篇将会较为全面的讲解有关红黑树的特点，插入操作，然后使用代码模拟实现红黑树，同时还会封装出红黑树的迭代器。
    在 STL 库中的 set 和 map 都是使用红黑树封装的，在前文中我们讲解了 AVL树，对于红黑树和 AVL 树来说，这两种树都是效率很高的搜索二叉树，但是相对而言 AVL 树会更加接近平衡二叉树，但是用于封装 set 和 map 的却是红黑树，这是因为虽然红黑树不是很接近平衡二叉树，但是和 AVL 树的搜索效率相比较其实相差不是很多，相反而言，对于红黑树在插入时

			
		

	



              


  
              

                


	

		

			

				
					
通用红黑树（Tree-Map）容器纯C实现

				
			

			

				

					08-05
				

			

		

		

			
				
纯C实现的通用红黑树容器不好找，于是自己琢磨着实现了一个。
算法部分直接剪裁自Linux内核中的rbtree
作者主要是在此基础上封装了一个通用的容器
里面含有 test例子 以及 benchmark基准测试

另外这个是Windows和Linux都可以用的
由于Linux内核的rbtree用了很多C99语法，笔者还得写了一些宏改造内核代码
Linux下的make是完整的
Windows下提供了VS08版的sln文件（只有test木有benchmark）
附带了一个C++里面的STL Map的benchmark

			
		

	





	

		

			

				
					
含迭代器的红黑树

				
			

			

				

					月已满西楼的博客
				

				

					06-08
					
					694
					
				

			

		

		

			
				
搜索二叉树含迭代器  
vs2013下编写的项目工程见 我的 github: https://github.com/excelentone/DataStruct#include<iostream>
using namespace std;
#include<cassert>
enum COLOR{ RED, BLACK };
template<class K, class V>
struct RBT

			
		

	



		

			
		



	

		

			

				
					
数据结构--迭代器实现红黑树

				
			

			

				

					sayhello_world的博客
				

				

					05-18
					
					1293
					
				

			

		

		

			
				
这次总结如何使用自己写的迭代器实现红黑树


一．什么是迭代器？
迭代器是连接容器和算法的纽带，为数据提供了抽象，使写算法的人不必关心各种数据结构的细节。迭代器提供了数据访问的标准模型——对象序列，使对容器更广泛的访问操作成为可能。
泛型编程的关键所在，就是如何找到一种通用的方法，来访问具有不同结构的各种容器中的每个元素，而这正是迭代器的功能。
迭代器是一种广义的指针，是指向序列元素指

			
		

	





	

		

			

				
					
C++_用红黑树实现关联容器map和set

				
			

			

				

					hello呀！
				

				

					08-21
					
					414
					
				

			

		

		

			
				
template <class K,class V>
class Map
{
private:
 struct MapKeyOfValue
 {
  const  K& operator()(const pair<K, V>& data)
  {
   return data.first;
  }
 };
public:
 typedef typename ...

			
		

	





	

		

			

				
					
C语言泛型红黑树实现及迭代器使用指南

				
			

			

				

					
				

			

		

		

			
				
接下来将详细探讨泛型红黑树的概念、C语言实现以及迭代器的实现细节。  ### 泛型红黑树概念  泛型编程允许程序员编写与数据类型无关的代码，这在C语言中通过宏定义、void指针和函数指针等技术手段实现。C语言的泛型...

			
		

	





	

		

			

				
					
c语言实现泛型红黑树(含迭代器) 见说明

				
			

			

				

					10-07
				

			

		

		

			
				
泛型纯C语法实现的底层容器 能想到的接口 都已实现  并单独提供一个正向迭代器与反向迭代器 ...其维护红黑树性质的相关代码 几乎是句句含带注释  使用面向对象编程思想构建代码 并可在windows和linux下 c89标准编译通过

			
		

	





	

		

			

				
					
红黑树精通指南：面试、实战与源码分析

					
热门推荐

				
			

			

				

					张彦峰的博客
				

				

					05-12
					
					177万+
					
				

			

		

		

			
				
本文深入探讨了红黑树的基本原理、实现方法及其在实际应用中的重要性。红黑树是一种自平衡的二叉搜索树，通过一系列颜色标记和旋转操作保证了查找、插入和删除操作的时间复杂度始终保持在 O(log n) 级别。文章首先介绍了红黑树的关键性质和与 AVL 树的区别，分析了红黑树在数据库索引、内存管理等领域的应用。接着，详细讲解了红黑树的插入和删除操作，以及如何通过旋转和颜色调整保持树的平衡。最后，文章通过源码分析展示了红黑树在 Java 和 Linux 内核中的实现，帮助读者更好地理解这一数据结构的实际应用和开发过程。

			
		

	





	

		

			

				
					
关于红黑树的迭代器原理及实现

				
			

			

				

					liuming
				

				

					11-11
					
					592
					
				

			

		

		

			
				
首先介绍什么是迭代器：

  迭代器是一种设计模式，设计一种结构依次序去遍历容器中的数据，而又无需暴露容器的底层设计细节，在我看来，迭代器的出现最重要的目的就是为了简单方便；同一种方式可以遍历不同的容器，不管底层结构是是顺序表，链表还是树。虽然使用方式相同，但是不同的容器中迭代器的实现方式是不同的，本文介绍红黑树的迭代器的实现方式。

迭代器的本质：

  本质上是指针或者对指针的封装。

如何设计容器中的迭代器：

  首先要明白容器的底层数据结构，按照什么规则进行遍历，其实使用一个类进行迭...

			
		

	





	

		

			

				
					
Cpp || 红黑树迭代器

				
			

			

				

					Template Code
				

				

					04-17
					
					614
					
				

			

		

		

			
				
红黑树迭代器


 迭代器的好处是可以方便遍历,是数据结构的底层实现与用户透明,如果想要给红黑树增加迭代器,需要考虑以前的问题:


begin()与end()



STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个...

			
		

	





	

		

			

				
					
红黑树的实现 以及加迭代器

				
			

			

				

					jhcconan614的博客
				

				

					06-03
					
					1391
					
				

			

		

		

			
				
在说红黑树之前，我们先来认识一下它：首先强调一点：红黑树也是二叉搜索树。那么它就满足二叉搜索树的性质，除此之外，他还有几个比较特殊的性质，了解这些，有助于我们后面的分析性质：1、红黑树所有的节点都有颜色（红或黑）2、红黑树的根结点是黑色的3、红黑树的两个红色节点不能相连4、红黑树的每一条链的黑节点的个数相同5、所有空的节点都是黑色的知道了这些之后开始进入红黑树的创建：显然这就是红黑树的插入操作的编写

			
		

	





	

		

			

				
					
红黑树封装 map/set 及其迭代器(C++)

				
			

			

				

					Brant_zero的博客
				

				

					11-26
					
					2854
					
				

			

		

		

			
				
使用红黑树封装map/set，并实现map/set的迭代器，支持成员访问、解引用、下标访问操作符++、-- 等功能.

			
		

	





	

		

			

				
					
C++红黑树的插入实现+红黑树迭代器实现+map/set封装红黑树

				
			

			

				

					qq_53413129的博客
				

				

					06-01
					
					706
					
				

			

		

		

			
				
红黑树的基本编写

红黑树的概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的



红黑树的性质

每个节点不是红色就是黑色
	根节点是黑色的
	没有连续的红色节点，但是可以有连续的黑色节点
	每条路径黑色节点数量相等
	每个叶子节点都是黑色的（此处的叶子节点值得是空节点--NIL节点，不是以前真正意义上理解的叶子节点）。
假设每条路径

			
		

	





	

		

			

				
					
红黑树底层迭代器的实现

				
			

			

				

					贵在坚持,我相信只要我努力,未来肯定是美好的!
				

				

					05-26
					
					387
					
				

			

		

		

			
				
红黑树实现迭代器目录:一. 封装迭代器二.红黑树部分改变三.map的实现四.set的实现
目录:

    这篇博客是对于红黑树内部迭代器实现,	点击红黑树的具体代码 .

一. 封装迭代器

       对于红黑树迭代器的实现,我们就是要利用二叉树的指向来依次的遍历对应的节点来实现红黑树的迭代器,所存在的_header节点就是方便迭代器的实现            

template<class V>
struct RBTreeIterator{		//泛型创建对应的结构

	typede

			
		

	





	

		

			

				
					
【数据结构】带迭代器的红黑树

				
			

			

				

					Cheng_913的博客
				

				

					01-27
					
					242
					
				

			

		

		

			
				
在上一篇博客中，我们简单的介绍了红黑树及其插入操作，下面我们将给红黑树封装一个迭代器。为方便操作，我们需要添加一个头结点，并设置其颜色为红色，以便于根结点区分开；这个根结点的左指向最小的结点，右指向树中值最大的结点，其双亲结点指向根结点，根结点的双亲域也指向头，如下图所示：



#pragma once
#include 
using namespace std;

enum COLOR

			
		

	





	

		

			

				
					
【C++】红黑树详解（附迭代器以及插入实现），适合初学者

				
			

			

				

					jhao的博客
				

				

					07-13
					
					2794
					
				

			

		

		

			
				
红黑树的简单实现附有迭代器实现，代码都有详细解释，适合于初学者和想要理解STL map/set原理的朋友观看。

			
		

	





	

		

			

				
					
源码阅读(17)：红黑树在Java中的实现和应用

				
			

			

				

					JAVA入门中
				

				

					10-13
					
					2327
					
				

			

		

		

			
				
红黑树又叫做自平衡二叉查找树，由于其稳定的查找特性，红黑树在Java中有广泛的应用——例如我们将要讲解的TreeMap容器和当前讲解的HashMap容器中都有对红黑树的应用。红黑树的操作原理相对于我们已经讲解过的堆树要复杂一些，但也并不是说无法理解，读者只需要跟随本节的介绍思路进行理解，并自行动手对其中提到的关键点进行验证，即可掌握红黑树的基本原理。

			
		

	





	

		

			

				
					
STL关联式容器之红黑树

				
			

			

				

					handsomeKyne
				

				

					07-12
					
					1495
					
				

			

		

		

			
				
这一节我们来学习红黑树，如果你能够自己实现一个红黑树，那么对它的理解将会更加深刻。
1、树的总览
根节点到任何节点之间有一条唯一路径。
路径长度：指路径所经过的边数。
节点的深度：根节点至该节点的路径长度。根节点的深度为0。
节点的高度：该节点到其最深叶节点的高度。根节点的高度最大。
注意高度和深度的区别。可以这么理解，高度是向上变大的，而深度是向下变大的。
节点大小：该节点所有子代

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值