C++实现红黑树与验证

最新推荐文章于 2022-12-20 16:11:42 发布
最新推荐文章于 2022-12-20 16:11:42 发布
阅读量345 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 红黑树 C 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010622045/article/details/47950547
版权 
#include<iostream>  
#include<stack>  
#include<vector>
using namespace std;  
const bool black = 0;  
const bool red = 1;  
struct RBNode  
{  
    int key;  
    bool color;  
    RBNode *llink, *rlink, *parent;  
};  
class RBTree  
{  
public:  
    RBTree();  
    ~RBTree();  
    int insertNode(int key);          //插入元素接口  
    int deleteNode(int key);          //删除元素接口  
    void nPreOrder();                 //先序遍历非递归  
    void nInOrder();                  //中序遍历非递归  
    void nPostOrder();                //后序遍历非递归  
    bool isRBTree();                  //验证是否是红黑树
private:  
    void destroy(RBNode **proot);     //销毁树，析构函数用到  
    RBNode *createNode(int key);      //生成红黑树结点  
    void insertFixup(RBNode *pnode);  //插入元素后调整  
    RBNode *searchNode(int key);      //找指定元素的结点，删除元素函数用到  
    void transplant(RBNode *v0, RBNode *v1); //删除指定结点,删除元素函数用到  
    RBNode *minNode(RBNode *x);             //找到树中最小的元素，删除元素函数用到  
    void deleteFixup(RBNode *delNode);      //删除元素后调整  
    RBNode *rotate_right(RBNode *a);        //右旋  
    RBNode *rotate_left(RBNode *a);         //左旋  
    RBTree(const RBTree &obj);  
    RBTree &operator=(const RBTree &obj);  
    RBNode *root;  
    RBNode *m_null;  
};  
//构造函数  
RBTree::RBTree()  
{  
    m_null = new RBNode;  
    m_null->color = black;  
    m_null->llink = m_null->rlink = m_null;  
    root = m_null;  
}  
//析构函数  
RBTree::~RBTree()  
{  
    if (root != m_null)  
    {  
        destroy(&root);  
        root = NULL;  
    }  
    delete m_null;  
    m_null = NULL;  
}  
//插入元素  
int RBTree::insertNode(int key)  
{  
    RBNode *p = root;  
    RBNode *parent = m_null;  
    while (p != m_null)  
    {  
        parent = p;  
        if (key == p->key)  
        {  
            return -1;  
        }  
        else if (key < p->key)  
        {  
            p = p->llink;  
        }  
        else  
        {  
            p = p->rlink;  
        }  
    }  
    RBNode *newNode = createNode(key);  
    if (parent == m_null)  
    {  
        root = newNode;  
        root->color = black;  
    }  
	else
	{
	    if (key < parent->key)  
	    {  
	        parent->llink = newNode;  
	    }  
	    else  
	    {  
	        parent->rlink = newNode;  
	    }  
	    newNode->parent = parent;  
	    insertFixup(newNode);              //插入元素后调整  
	}
    return 0;
}  
//插入元素后调整  
void RBTree::insertFixup(RBNode *pnode)  
{  
    RBNode *parent = pnode->parent;  
    RBNode *grandParent = m_null;  
    while (parent != m_null&&parent->color == red)      //迭代  
    {  
        grandParent = parent->parent;  
        if (parent == grandParent->llink)  
        {  
            RBNode *uncle = grandParent->rlink;  
            if (uncle->color == red)                                //情况1  
            {  
                parent->color = black;  
                uncle->color = black;  
                grandParent->color = red;  
                pnode = grandParent;  
                parent = pnode->parent;  
            }  
            else  
            {  
                if (pnode == parent->rlink)                        //情况2，可转换为情况3  
                {  
                    pnode = rotate_left(parent);  
                    parent = pnode->parent;  
                    grandParent = parent->parent;  
                }  
                parent->color = black;                            //情况3  
                grandParent->color = red;  
                rotate_right(grandParent);  
            }  
        }  
        else                                                      //与上面对称  
        {  
            RBNode *uncle = grandParent->llink;  
            if (uncle->color == red)  
            {  
                parent->color = black;  
                uncle->color = black;  
                grandParent->color = red;  
                pnode = grandParent;  
                parent = pnode->parent;  
            }  
            else  
            {  
                if (pnode == parent->llink)  
                {  
                    pnode = rotate_right(parent);  
                    parent = pnode->parent;  
                    grandParent = parent->parent;  
                }  
                parent->color = black;  
                grandParent->color = red;  
                rotate_left(grandParent);  
            }  
        }  
    }  
    root->color = black;  
}  
//寻找指定键值元素  
RBNode *RBTree::searchNode(int key)  
{  
    RBNode *p = root;  
    while (p != m_null)  
    {  
        if (key == p->key)  
        {  
            return p;  
        }  
        else if (key < p->key)  
        {  
            p = p->llink;  
        }  
        else  
        {  
            p = p->rlink;  
        }  
    }  
    return m_null;  
}  
//删除元素后调整各结点关系  
void RBTree::transplant(RBNode *v0, RBNode *v1)  
{  
    if (v0 == root)  
    {  
        root = v1;  
		root->parent=m_null;
    }  
    else if (v0 == v0->parent->llink)  
    {  
        v0->parent->llink = v1;  
    }  
    else  
    {  
        v0->parent->rlink = v1;  
    }  
    v1->parent = v0->parent;  
}  
//找到树中最小健值结点  
RBNode *RBTree::minNode(RBNode *x)  
{  
    while (x->llink != m_null)  
    {  
        x = x->llink;  
    }  
    return x;  
}  
//删除指定健值结点  
int RBTree::deleteNode(int key)  
{  
    RBNode *delNode = searchNode(key);            //寻找删除的结点  
    if (delNode == m_null)  
    {  
        return -1;  
    }  
    RBNode *realDel = delNode;                  //实际删除的结点赋初值  
    RBNode *replace = m_null;                   //代替的结点  
    if (delNode->rlink == m_null)               //如果删除的结点最多只有1棵子树  
    {  
        replace = delNode->llink;  
    }  
    else if (delNode->llink == m_null)  
    {  
        replace = delNode->rlink;  
    }  
    else                                       //如果有两个子树  
    {  
        realDel = minNode(delNode->rlink);     //找到右子树最小结点，即为实际要删除的结点  
        replace = realDel->rlink;  
        delNode->key = realDel->key;           //实际删除的结点值赋给删除的结点  
    }  
    transplant(realDel, replace);  
    if (realDel->color == black)  
    {  
        deleteFixup(replace);             //如果实际删除的结点是黑色，则调整  
    }  
    delete realDel;  
	return 0;
}  

//删除结点后调整  
void RBTree::deleteFixup(RBNode *delNode)  
{  
    RBNode *p = delNode;  
  
    while (p != root&&p->color == black)  
    {  
        RBNode *parent = p->parent;  
        if (p == parent->llink)  
        {  
            RBNode *slibing = parent->rlink;  
            if (slibing->color == red)                                       //情况1，兄弟结点为红色 可转换为情况2，3，4  
            {                                                               //兄弟结点涂成黑色，父结点凃成红色，以父结点为支点左旋   
                parent->color = red;  
                slibing->color = black;  
                rotate_left(parent);  
                slibing = parent->rlink;                                     //调整兄弟结点  
            }  
            //此时兄弟结点肯定为黑色  
            if (slibing->llink->color == black&&slibing->rlink->color == black)       //情况2，两个侄子结点都为黑色  
            {  
                slibing->color = red;                                        //兄弟结点凃红  
                p = parent;                                               	 //父结点为当前节点  
            }  
            else  
            {  
                if (slibing->rlink->color == black)                                 //情况3，左侄子结点为红色  
                {  
                    slibing->color = red;                                    //兄弟凃红  
                    slibing->llink->color = black;                           //左侄子凃红  
                    rotate_right(slibing);                                   //以兄弟为支点右旋  
                    slibing = slibing->parent;                               //调整兄弟结点转换为情况4  
                }  
                slibing->color = parent->color;                               //情况4 ，右侄子为红  
                parent->color = black;                                       //父结点与兄弟结点交换颜色  
                slibing->rlink->color = black;                                //右侄子凃黑后结束  
                rotate_left(parent);                                        //以父结点为支点左旋  
                p = root;                                                   
            }  
        }  
        else                                                                 //与上面对称  
        {  
            RBNode *slibing = parent->llink;  
            if (slibing->color == red)  
            {  
                slibing->color = black;  
                parent->color = red;  
                rotate_right(parent);  
                slibing = parent->llink;  
            }  
            if (slibing->llink->color == black&&slibing->rlink->color == black)  
            {  
                slibing->color = red;  
                p = parent;  
            }  
            else  
            {  
                if (slibing->llink->color == black)  
                {  
                    slibing->color = red;  
                    slibing->rlink->color = black;  
                    rotate_left(slibing);  
                    slibing = slibing->parent;  
                }  
                slibing->color = parent->color;  
                parent->color = black;  
                slibing->llink->color = black;  
                rotate_right(parent);  
                p = root;  
            }  
        }  
    }  
    p->color = black;  
}  
//右旋 				
RBNode *RBTree::rotate_right(RBNode *a)  
{  
    RBNode *b = a->llink;  
    if (b == m_null)  
    {  
        return a;  
    }  
    a->llink = b->rlink;  
    b->rlink->parent = a;  
    if (root == a)  
    {  
        root = b;  
        b->parent = m_null;  
    }  
    else  
    {  
        if (a->parent->llink == a)  
        {  
            a->parent->llink = b;  
        }  
        else  
        {  
            a->parent->rlink = b;  
        }  
        b->parent = a->parent;  
    }  
    b->rlink = a;  
    a->parent = b;  
    return a;  
}  
//左旋  
RBNode *RBTree::rotate_left(RBNode *a)  
{  
    RBNode *b = a->rlink;  
    if (b == m_null)  
    {  
        return a;  
    }  
    a->rlink = b->llink;  
    b->llink->parent = a;  
    if (root == a)  
    {  
        root = b;  
        b->parent = m_null;  
    }  
    else  
    {  
        if (a->parent->llink == a)  
        {  
            a->parent->llink = b;  
        }  
        else  
        {  
            a->parent->rlink = b;  
        }  
        b->parent = a->parent;  
    }  
    b->llink = a;  
    a->parent = b;  
    return a;  
}  
//销毁树，析构函数调用  
void RBTree::destroy(RBNode **proot)  
{  
    if (*proot == m_null)  
    {  
        return;  
    }  
    destroy(&(*proot)->llink);  
    destroy(&(*proot)->rlink);  
    delete *proot;  
    *proot = m_null;  
}  
RBNode *RBTree::createNode(int key)  
{  
    RBNode *p = new RBNode;  
    if (p)  
    {  
        p->color = red;  
        p->key = key;  
        p->llink = p->rlink = p->parent = m_null;  
    }  
    return p;  
}  
//先序遍历非递归  
void RBTree::nPreOrder()  
{  
    if (root == m_null)  
    {  
        return;  
    }  
    stack<RBNode*> st;  
    RBNode *p = root;  
    st.push(p);  
    while (!st.empty())  
    {  
        p = st.top();  
        st.pop();  
        if (p != m_null)  
        {  
            cout << p->key << ' ';  
            st.push(p->rlink);  
            st.push(p->llink);  
        }  
    }  
    cout << endl;  
}  
//中序遍历非递归  
void RBTree::nInOrder()  
{  
    if (root == m_null)  
    {  
        return;  
    }  
    stack<RBNode*> st;  
    RBNode *p = root;  
    while (p != m_null || !st.empty())  
    {  
        while (p != m_null)  
        {  
            st.push(p);  
            p = p->llink;  
        }  
        p = st.top();  
        st.pop();  
        cout << p->key << ' ';  
        p = p->rlink;  
    }  
    cout << endl;  
}  
//后序遍历非递归  
void RBTree::nPostOrder()  
{  
    if (root == m_null)  
    {  
        return;  
    }  
    stack<RBNode*> st;  
    RBNode *p = root;  
    RBNode *pp = m_null;  
    while (p != m_null || !st.empty())  
    {  
        while (p != m_null)  
        {  
            st.push(p);  
            pp = p->rlink;  
            p = p->llink;  
            if (p == m_null)  
            {  
                p = pp;  
            }  
        }  
        p = st.top();  
        st.pop();  
        cout << p->key << ' ';  
        if (!st.empty() && st.top()->llink == p)  
        {  
            p = st.top()->rlink;  
        }  
        else  
        {  
            p = m_null;  
        }  
    }  
    cout << endl;  
}  
//判断是否是红黑树
bool RBTree::isRBTree()
{
	if (root == m_null)  
    {  
        return true;  
    }  
	vector<RBNode*> st;
	RBNode *p=root;
	RBNode *pp=m_null;
	int num=0;
	int black_num=0;
	//1、根节点是黑色
	if(p->color==red)                          
		return false;
	while(p!=m_null||!st.empty())
	{
		while(p!=m_null)
		{
			st.push_back(p);
			pp=p->rlink;
			p=p->llink;
			if(p==m_null)
				p=pp;
		}
		p=st.back();
		st.pop_back();
		//2、每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
		if(p->color==red&&(p->llink->color!=black||p->rlink->color!=black))
			return false;
		//3、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点
		if(p->llink==m_null&&p->rlink==m_null)
		{
			black_num=0;
			for(vector<RBNode*>::iterator iter=st.begin();iter!=st.end();++iter)
			{
				if((*iter)->color==black)
					black_num++;
			}
			if(p->color==black)
				black_num++;
			if(num==0)
				num=black_num;
			else if(num!=black_num)
				return false;
		}

		if(!st.empty()&&st.back()->llink==p)
			p=st.back()->rlink;
		else
			p=m_null;
	}
	return true;
}
#include<stdlib.h>
#define N 1000
#define random(i) (rand()%i)
int main()  
{  
    RBTree tree;  
    int num=0;
	while(num<N)       //插入N个不同的随机节点
	{
		if(tree.insertNode(random(N))==0)
		{
			num++;
			if(tree.isRBTree()==false)                //插入节点后判断是否是红黑树
				cout<<"insert error"<<endl;
		}
	}
    tree.nPreOrder(); 
	cout<<"======================"<<endl;
    tree.nInOrder();  
	cout<<"======================"<<endl;
    tree.nPostOrder();  
	cout<<"======================"<<endl;

	num=0;
	while(num<N)      //删除N个不同的随机节点
	{
		if(tree.deleteNode(random(N))==0)
		{
			num++;
			if(tree.isRBTree()==false)               //删除节点后判断是否是红黑树
				cout<<"delete error"<<endl;
		}
	}
    return 0;  
}

Howard_Hua
关注
专栏目录
红黑树的实现与验证--C++
一只IT小小鸟
03-07 1232
红黑树的实现与验证--C++红黑树实例：在说红黑树之前，我们先来认识一下它：首先强调一点：红黑树也是二叉搜索树。那么它就满足二叉搜索树的性质，除此之外，他还有几个比较特殊的性质，了解这些，有助于我们后面的分析性质：1、红黑树所有的节点都有颜色（红或黑）2、红黑树的根结点是黑色的3、红黑树的两个红色节点不能相连4、红黑树的每一条链的黑节点的个数相同5、所有空的节点都是黑色的知道了这些之后开始进...
C++实现红黑树
最新发布
weixin_42381791的博客
02-01 237
代码中还涉及到红黑树的前中后序遍历的递归算法和非递归算法，并打印出来，不过红黑树的删除在代码中没有体现，删除节点操作相对于增加节点操作更加复杂，等以后再补上。总结：红黑树是一种自平衡二叉查找树，特点：查找速度快且中序遍历是顺序的，应用于任务调度（CFS），内存管理等等。
红黑树的插入与验证——附图详解
bestme
11-22 4438
首先对于一个新节点的插入，这个新节点我们需要先默认设置为红色，那为什么不设置成黑色呢？在插入新节点之前，这棵树肯定已经是红黑树了，那么它就满足性质4（任意结点节点到叶子结点路径上黑色节点个数相等），而如果这时候插入一个黑色的节点，那肯定会破坏这个性质。而我们设定新节点为红色的，那只是可能会破坏性质3（不存在连续两红），但是我们可以通过修改结点颜色或者树的结构来纠正这棵红黑树。
实现红黑树（已leetcode验证）
zt_xiaozhi
03-16 930
代码已在leetcode验证了。是正确的，内存稍微多一些，时间上要好一些。大家可以看看下提交记录中的内存和时间差异。 其他两种平衡二叉树参考 [[AVL 树]] [[跳表]] 在红黑树的学习过程中，我接触到两种红黑树的描述，一种是左偏红黑树，另一种是算法导论中一般意义上的红黑树。前者是红黑树的简化版本。本偏只是原理和实现，没有说应用。 红黑树的左偏和右偏版本 左偏红黑树被设计为和一种叫2-3树的等价树，左偏红黑树是2-3树的另一种结构表现形式。 这很好，因为2-3树是绝对平衡的二叉搜索树！ 2-3树
手撕红黑树的构建与验证
naititi的博客
12-20 480
红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O( logN)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。
红黑树旋转的通俗易懂版本以及判断一个树是否为红黑树
来信
09-23 1648
红黑树属于二叉搜索树，但是每个节点增加了一个存颜色的位，它的规则是： 1.根节点为黑色。 2.不能有连续的两个红节点，所以如果一个节点的颜色为红，那么它的子节点若不为空则一定为红。 3.每条路径上黑节点数量相同。 所以保证了最长路径不超过最短路径的两倍，没有AVL树那么严格的平衡，但是旋转少效率高，也是O(LgN）。 判断一棵树是否为红黑树： bool IsRB() { if (_r...
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3156
红黑树详解
C++红黑树
zhao19971014的博客
11-09 601
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的
红黑树与区间树算法实现
04-08
在实验中，`RedBlackTree.c`和`RedBlackTree.h`文件包含了红黑树的实现，包括插入、删除、旋转、查找等操作。`Tree.dot`文件用于生成红黑树的图形表示，通过graphviz工具可视化。 区间树是一种特殊的树形数据结构，...
红黑树-使用C++实现-简单练习
12-05
在C++中实现红黑树，需要对数据结构和算法有深入理解。 在给定的文件中，"rbtree.cpp"很可能是实现红黑树节点定义和操作的代码，包括旋转、颜色调整、插入和删除等功能。"main.cpp"则是测试和驱动程序，用于验证...
一步一步彻底实现红黑树，面试不再愁
09-26
手把手实现红黑树，一步一步彻底实现红黑树，面试不再愁。...
算法导论的红黑树的C++实现源码
03-29
下面我们将详细探讨红黑树的特性、C++实现的关键点以及测试验证的方法。 红黑树的主要特性： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是黑色。 4. 如果一个节点是...
建立红黑树（左旋、右旋、插入、维护）代码+验证
xd_huch的专栏
10-22 1456
关于红黑树的理论讲解,网上有很多，大家可以自己找，这里重点在于实现一下，代码供大家参考。
STL关联式容器之红黑树
handsomeKyne
07-12 1435
这一节我们来学习红黑树，如果你能够自己实现一个红黑树，那么对它的理解将会更加深刻。 1、树的总览 根节点到任何节点之间有一条唯一路径。 路径长度：指路径所经过的边数。 节点的深度：根节点至该节点的路径长度。根节点的深度为0。 节点的高度：该节点到其最深叶节点的高度。根节点的高度最大。 注意高度和深度的区别。可以这么理解，高度是向上变大的，而深度是向下变大的。 节点大小：该节点所有子代
c++——红黑树
Britney_dark的博客
11-13 4733
愿你终将与重要的人重逢！
判断是否为红黑树
qq_54869075的博客
11-14 1080
红黑树条件 根为黑 红结点的子结点黑 对于每个结点，从该结点到后代叶子的所有简单路径都包含相同数量的黑色结点 结点定义 typedef struct RBTnode { int data; bool color; // 0 for black, 1 for red RBTnode *lchild, *rchild; int left, right, it; } * RBTree, Node, *node; 判断方式 第一步判断根的颜色是否为黑 判断红结点的...
判断所给二叉树是否是红黑树
u010209218的专栏
10-22 2768
先总结下知识点。 红黑树就是带有颜色的平衡二叉搜索树加五个特殊属性 1，所有节点只能是红或黑色 2，所有叶子都是黑色，并且不存有效数据（如果你要自己构造一个红黑树，叶子节点设置为null就可以，其实就是你的结构存储完所有有效数据后把当前的叶子节点（这些叶子是存有有效数据的）当成内节点，给他们一个构造一个null的叶子节点） 3，根节点只能是黑色 4，每个红节点必有两个子黑节点，即不能有连
JAVA实践红黑树-小试牛刀
薛定谔的猫窝
08-24 4962
前言第一感觉是和AVL树差别不是特别大，没有很直观的感受到效率的巨大提升，作为一个小小的强迫症患者，还是AVL树更好看。不过讲道理，平衡被破坏次数相同情况下，红黑树的确少了那么一些旋转。。。因为插入节点后平衡被破坏时，红黑树的会选择旋转或变色。 AVL树则只有旋转。另外我发现其他的大神写法，跟我的有点差距。。。有心人可以帮我瞄一眼，我是不是哪里错了，在此先谢过了~~另外一个参考网站、博客、PDF：
红黑树详解：数据结构与C++实现
同时，`red_black_tree.c`文件可能包含了具体的节点结构定义和操作实现，而`rbtree_test.c`则是测试用例，用于验证红黑树功能的正确性。 为了使用红黑树，你需要包含`red_black_tree.h`，并调用相应的接口进行操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值