利用红黑树自己编写 C++ MAP

最新推荐文章于 2023-11-13 00:32:18 发布
最新推荐文章于 2023-11-13 00:32:18 发布
阅读量176 收藏
点赞数
文章标签： c/c++ 数据结构与算法
原文链接：https://my.oschina.net/llmm/blog/160078
版权

    搞定红黑树，就想着写来玩玩。于是，就配合C++的模板技术写了一个简单的Map。

    看了一些博客，个人感觉还是Wiki上讲红黑树讲的清晰一些，我承认没完全看懂算法导论上删除结点的树调整,连他的二叉树删除节点都看晕我了,还不如直接写来的快。下面是我总结了一下插入结点和删除结点的树调整：
     

    

    自己写的Map简单一些，没有考虑很多工程因素。模板类MyMap向外提供public的接口有：

  1. insert()    //插入一个key-value结点

  2. remove()    //删除值为value的结点

  3. query()    //查询key对应的结点的value，返回value的常引用保证用户不会直接修改树

  4. modify()    //修改key对应的结点值为value

  5. show()    //这个值的说……是我自己推导的字符界面显示树型的程序，不过推导时假定了每个结点显示的东西只占一格，所以当结点value占位超过两格时树型就不太对了。参数为1时，显示value树，为0时显示树的RB信息(这个给我调程序帮了很大的忙)。

    代码如下： 

#pragma once

#include<iostream>
#include<string>
#include<queue>
using namespace std;

template <typename KT,typename VT>
class MyMap		//自定义类,键重载=和<，值重载=
{
private:
	class Node
	{
	public:
		Node(KT k,VT v,int c,Node* f);
		bool IsLeaf();
		int id,color;
		KT key;VT value;
		Node *father,*lchild,*rchild;	
	};
public:
	MyMap():RED(1),BLACK(-1),T(NULL){}
	void insert(const KT& key,const VT& value);
	void remove(const KT& key);
	const VT& query(const KT& key);
	void modify(const KT& key,const VT& value);
	void show(int mode);
private:
	Node* NewNode(KT k,VT v,int c,Node* f);
	void IAdjust(Node* p);
	void DAdjust(Node* p);
	void LRotate(Node* p);
	void RRotate(Node* p);
	Node* Brother(Node* p);
	Node* Uncle(Node* p);
	Node* Next(Node* p);
	Node* Pre(Node* p);
	Node* find(const KT& key);
	int Depth(Node* T);
	string Space(int n);
private:
	MyMap(const MyMap<KT,VT>&);
	MyMap operator = (const MyMap<KT,VT>&);
	const int RED,BLACK; Node* T;
};

template <typename KT,typename VT>
void MyMap<KT,VT>::insert(const KT& key,const VT& value)
{
	Node* p=T;
	if(p==NULL) 
		p=T=NewNode(key,value,RED,NULL);
	else
	{
		Node* f=T;
		while(!p->IsLeaf())
		{
			f=p;
			if(key<p->key) p=p->lchild;
			else if(key>p->key) p=p->rchild;
			else return ;
		}
		if(key<f->key)
		{
			delete f->lchild;
			p=f->lchild=NewNode(key,value,RED,f);
		}
		else
		{
			delete f->rchild;
			p=f->rchild=NewNode(key,value,RED,f);
		}
	}
	IAdjust(p);
}

template <typename KT,typename VT>
void MyMap<KT,VT>::IAdjust(Node* p)
{
	while(true)
	{
		if(p->father==NULL)	//case 1
		{
			p->color=BLACK;
			return ;
		}
		else if(p->father->color==BLACK)	//case 2
			return ;
		else
		{
			if(Uncle(p)->color==RED)	//case 3
			{
				p->father->color=BLACK;
				Uncle(p)->color=BLACK;
				p=p->father->father;
				p->color=RED;
			}
			else	
			{
				if(p->father==p->father->father->lchild)
				{
					if(p==p->father->rchild)	//case 4
						LRotate(p->father);
					else p=p->father;	//case 5
					p->father->color=RED;
					RRotate(p->father);
				}
				else
				{
					if(p==p->father->lchild)	//case 4'
						RRotate(p->father);
					else p=p->father;	//case 5'
					p->father->color=RED;
					LRotate(p->father);
				}
				p->color=BLACK; return ;
			}
		}
	}
}

template <typename KT,typename VT>
typename MyMap<KT,VT>::Node* MyMap<KT,VT>::Brother(Node* p)
{
	if(p->father==NULL) return NULL;
	else
	{
		if(p==p->father->lchild) return p->father->rchild;
		else p->father->lchild;
	}
}

template <typename KT,typename VT>
typename MyMap<KT,VT>::Node* MyMap<KT,VT>::Uncle(Node* p)
{
	if(p->father==NULL) return NULL;
	p=p->father;
	if(p->father==NULL) return NULL;
	else return Brother(p);
}

template <typename KT,typename VT>
void MyMap<KT,VT>::LRotate(Node* p)
{
	Node* f=p->father;
	Node* r=p->rchild;
	if(r->IsLeaf()) return;
	p->rchild=r->lchild;
	if(r->lchild!=NULL)
		r->lchild->father=p;
	r->lchild=p;p->father=r;
	if(f!=NULL)
	{
		if(p==f->lchild) f->lchild=r;
		else f->rchild=r;
	}
	else T=r;
	r->father=f;
}

template <typename KT,typename VT>
void MyMap<KT,VT>::RRotate(Node* p)
{
	Node* f=p->father;
	Node* l=p->lchild;
	if(l->IsLeaf()) return;
	p->lchild=l->rchild;
	if(l->rchild!=NULL)
		l->rchild->father=p;
	l->rchild=p; p->father=l;
	if(f!=NULL)
	{
		if(p==f->lchild) f->lchild=l;
		else f->rchild=l;
	}
	else T=l;
	f->father=l;
}

template <typename KT,typename VT>
void MyMap<KT,VT>::remove(const KT& key)
{
	Node* p=find(key),*n=NULL;
	if(p==NULL) return ;
	if(p->lchild->IsLeaf()&&p->rchild->IsLeaf())
	{
		if(p->father==NULL) {T=NULL;return;}
		if(p==p->father->lchild)
			n=p->father->lchild=p->lchild;
		else n=p->father->rchild=p->lchild;
		n->father=p->father;
		delete p->rchild;
	}
	else if(p->lchild->IsLeaf())
	{
		if(p->father==NULL)
		{
			n=T=p->rchild;
			n->father=NULL;
		}
		else
		{
			if(p==p->father->lchild)
				n=p->father->lchild=p->rchild;
			else n=p->father->rchild=p->rchild;
			n->father=p->father;
		}
		delete p->lchild;
	}
	else if(p->rchild->IsLeaf())
	{
		if(p->father==NULL)
		{
			n=T=p->lchild;
			n->father=NULL;
		}
		else
		{
			if(p==p->father->lchild)
				n=p->father->lchild=p->lchild;
			else n=p->father->rchild=p->lchild;
			n->father=p->father;
		}
		delete p->rchild;
	}
	else
	{
		n=Next(p);
		if(n==n->father->lchild)
			n->father->lchild=n->rchild;
		else n->father->rchild=n->rchild;
		n->rchild->father=n->father;
		p->key=n->key,p->value=n->value;
		delete n->lchild;
		p=n,n=n->rchild;
	}
	if(p->color==BLACK) DAdjust(n);
	delete p;
}

template <typename KT,typename VT>
void MyMap<KT,VT>::DAdjust(Node* n)
{
	while(true)
	{
		if(n->father==NULL)	//case 1
		{				
			n->color=BLACK,T=n;	
			return ;
		}
		else
		{
			if(Brother(n)!=NULL&&Brother(n)->color==RED)	//case 2 ---> 3/4/5
			{
				n->father->color=RED;
				Brother(n)->color=BLACK;
				if(n==n->father->lchild)	LRotate(n->father);
				else RRotate(n->father);
			}
			else
			{
				Node* b=Brother(n);
				if(n==n->father->lchild&&b->rchild->color==RED)	//case 3
				{
					b->color=n->father->color;
					n->father->color=BLACK;
					b->rchild->color=BLACK;
					LRotate(n->father);
					return ;
				}
				else if(n==n->father->rchild&&b->lchild->color==RED)	//case 3'
				{
					b->color=n->father->color;
					n->father->color=BLACK;
					b->lchild->color=BLACK;
					RRotate(n->father);
					return ;
				}
				else
				{
					if(n==n->father->lchild&&b->lchild->color==RED)	//case 4 ---> 3
					{
						b->color=RED;
						b->lchild->color=BLACK;
						RRotate(b);
					}
					else if(n==n->father->rchild&&b->rchild->color==RED)	//case 4' --->3
					{
						b->color=RED;
						b->rchild->color=BLACK;
						LRotate(b);
					}
					else
					{
						if(n->father->color==RED)	//case 5
						{
							n->father->color=BLACK;
							Brother(n)->color=RED;
							return ;							
						}
						else	//case 6 --->1/2/3/4/5
						{
							b->color=RED;
							n=n->father;
						}
					}
				}
			}
		}
	}		
}

template <typename KT,typename VT>
const VT& MyMap<KT,VT>::query(const KT& key)
{
	Node* p=find(key);
	if(p==NULL) return NULL;
	else return p->value;
}

template <typename KT,typename VT>
void MyMap<KT,VT>::modify(const KT& key,const VT& value)
{
	remove(key);
	insert(key,value);
}

template <typename KT,typename VT>
typename MyMap<KT,VT>::Node* MyMap<KT,VT>::Pre(Node* x)
{
	Node* p=x;
	if(!p->lchild->IsLeaf())
	{
		p=p->lchild;
		while(!p->rchild->IsLeaf()) p=p->rchild;
		return p;
	}
	else
	{
		while(p->father!=NULL&&p!=p->father->rchild) 
			p=p->father;
		return p->father;
	}
}

template <typename KT,typename VT>
typename MyMap<KT,VT>::Node* MyMap<KT,VT>::Next(Node* x)
{
	Node* p=x;
	if(!p->rchild->IsLeaf())
	{
		p=p->rchild;
		while(!p->lchild->IsLeaf()) p=p->lchild;
		return p;
	}
	else
	{
		while(p->father!=NULL&p!=p->father->lchild)
			p=p->father;
		return p->father;
	}
	return NULL;
}

template <typename KT,typename VT>
typename MyMap<KT,VT>::Node* MyMap<KT,VT>::find(const KT& key)
{
	Node* p=T;
	while(!p->IsLeaf())
	{
		if(key==p->key) return p;
		else if(key<p->key) p=p->lchild;
		else p=p->rchild;
	}
	return NULL;
}

template <typename KT,typename VT>
void MyMap<KT,VT>::show(int mode)
{
	if(T==NULL)
	{
		cout<<"It's a empty tree!"<<endl;
		return ;
	}
	queue<Node> Q;
	int pl=0,pid=0,H=Depth(T),h=0;
	T->id=1;
	Q.push(*T);					
	while(!Q.empty())
	{
		Node& p=Q.front();
		for(h=0;;h++)	
			if((1<<h)>=p.id+1) break;
		int offset=(1<<(H-h+1))-1;
		if(h==pl) 
		{												
			cout<<Space((p.id-pid)*offset)<<Space(p.id-pid-1);
			if(mode) cout<<p.value;
			else
			{
				if(p.color==RED) cout<<"R";
				else cout<<"B";
			}
			pid=p.id;
		}
		else 
		{
			pid=1<<(h-1);
			int of=(1<<(H-h))-1;
			cout<<endl<<Space(of)<<Space((p.id-pid)*offset)<<Space(p.id-pid);
			if(mode) cout<<p.value;
			else
			{
				if(p.color==RED) cout<<"R";
				else cout<<"B";
			}
			pid=p.id;pl=h;
		}
		Q.pop();
		if(!p.lchild->IsLeaf())
		{
			p.lchild->id=p.id*2;
			Q.push(*p.lchild);
		}
		if(!p.rchild->IsLeaf())
		{
			p.rchild->id=p.id*2+1;
			Q.push(*p.rchild);
		}
	}
	cout<<endl<<endl;
}

template <typename KT,typename VT>
int MyMap<KT,VT>::Depth(Node* T)
{
	if(T->IsLeaf()) return 0;
	int a=Depth(T->lchild)+1;
	int b=Depth(T->rchild)+1;
	return a>b?a:b;
}

template <typename KT,typename VT>
string MyMap<KT,VT>::Space(int n)
{
	string s=string("");
	for(int i=0;i<n;i++) s+=" ";
	return s;
}

template <typename KT,typename VT>
MyMap<KT,VT>::Node::Node(KT k,VT v,int c,Node* f)
{
	key=k;value=v;
	color=c;father=f; 
	lchild=rchild=NULL;
}

template <typename KT,typename VT>
typename MyMap<KT,VT>::Node* MyMap<KT,VT>::NewNode(KT k,VT v,int c,Node* f)
{
	Node* p=new Node(k,v,c,f);
	p->lchild=new Node(KT(),VT(),BLACK,p);
	p->rchild=new Node(KT(),VT(),BLACK,p);
	return p;
}

template <typename KT,typename VT>
bool MyMap<KT,VT>::Node::IsLeaf()
{
	if(lchild==NULL&&rchild==NULL) 
		return true;
	else return false;
}



 

转载于:https://my.oschina.net/llmm/blog/160078

chuanyang6282
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
＜map与set的模拟实现＞——《C++高阶》
m0_57859086的博客
08-14 714
——《》C++高阶
学习-＞C++篇十五：红黑树和map,set
u014801954的博客
10-18 757
目录 一 . 红黑树的定义（规则）： 二 . 红黑树是如何保持平衡的？ 插入操作： 情况一：叔叔节点存在且为红色 情况二：叔叔节点不存在或存在且为黑色 三.map和set如何封装？
【C++】手把手教你实现自己的set 和map
就爱摆烂
03-25 1518
map and set , AVLTree, RBTree 的讲解
【C++】红黑树 --- map/set 底层
最新发布
YoungMLet的博客
11-13 1201
了解 map/set 底层红黑树的插入！使用红黑树封装 map/set ！
【C++】map与set容器——红黑树底层封装
Pursue quality, not quantity.
04-04 988
map和set的介绍，以及如何用红黑树封装map和set，细节拉满！
c++实现的简易map
04-06
在C++标准库中，`std::map`是一个红黑树实现的关联容器，提供O(log n)的时间复杂度进行插入、删除和查找操作。然而，自定义的简易`Map`可能不包含所有这些特性，但通常会实现基本的键值对存储和访问功能。以下是一些...
红黑树可运行代码C++ 使用无父指针的节点构造
01-08
使用该红黑树编写的Map通过部分OJ，未发现bug。 /* 此版本无父指针，旋转时用栈确定祖先。 使用该红黑树编写的Map通过部分OJ，未发现bug */ #include #include #include #include #include using namespace std; #...
红黑树 C++ 源代码 数据结构 算法
12-29
在学习红黑树的过程中，理解其基本概念和性质是首要步骤，然后通过实际编写和调试C++源代码加深理解。实践是检验理论的最好方式，通过实现和测试红黑树的各种操作，可以更好地掌握这种数据结构的精髓。同时，对于...
C++中vector可以作为map的键值实例代码
08-30
Map容器使用红黑树作为底层数据结构，红黑树是一种自平衡二叉搜索树，它可以在O(log n)时间内实现插入、删除和查找操作。为了实现这种高效的查找，map容器要求键值类型必须定义合法的比较运算符，以便确定键值之间的...
控制台打印红黑树.rar
05-17
在实际编程中，红黑树常用于实现关联数组、映射、集合等数据结构，例如C++标准库中的`std::map`和`std::set`。由于其良好的平衡性能，红黑树在高效算法和数据结构设计中扮演着重要角色。 了解和掌握红黑树的原理与...
Map (c++实现的简易map)
03-16
vs2013 自己实现的一个简易Map(c++)。
C++ 红黑平衡树的实现
07-15
按照红黑平衡树的原理，实现的一个二叉树，key value的模板类，实现了数据的添加和快速的查找等功能
用Ｃ模访写一个c++ map
05-14
用纯c代码模仿写的一个c++ map。底层的数据存储采用的是红黑树，上面为了支持所有的数据类型，写成一个通用的c map，大量的采用了宏函数。这个c map基本上支持所有的数据类型，只是用起来不如c++方便。
【C++】红黑树（Red Black Tree）
knous
08-04 444
红黑树的一些操作
【C++】红黑树详解（附迭代器以及插入实现），适合初学者
jhao的博客
07-13 2368
红黑树的简单实现附有迭代器实现，代码都有详细解释，适合于初学者和想要理解STL map/set原理的朋友观看。
C++ map的底层实现为什么是红黑树
sinat_31608641的博客
11-12 1243
map的底层原理
【C++】map&set利用红黑树进行简单封装
QiHai的博客
11-16 468
基于红黑树实现简单封装map和set。
c语言map的实现-使用内核红黑树
热门推荐
staticnetwind的专栏
09-27 2万+
一、前言 内核数据结构中，上次讲了一次内核链表的使用《c语言双向循环链表实现-使用内核链表》，这次再接着讲一下内核中常用的&lt;key,value&gt;结构，红黑树（rbtree）。 二、相关知识 2.1 红黑树特点 红黑树为自平衡二叉查找树，具备了以下几种特征[1]： 节点是红色或黑色。 根是黑色。 所有叶子都是黑色（叶子是NIL节点）。 每个红色节点必须有两个黑色的子节点...
stl map底层之红黑树插入步骤详解与代码实现
mxway的专栏
06-08 2万+
文章用图片的方式对红黑树插入过程的调整进行了详细解释。并给出红黑树插入调整实现的C++源码。
c++stl，map和unordered_map
06-28
map是一种有序的关联容器，它使用红黑树实现，可以快速地查找、插入和删除元素，但是它的空间复杂度较高。unordered_map是一种无序的关联容器，它使用哈希表实现，可以在常数时间内查找、插入和删除元素，但是它的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值