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

最新推荐文章于 2023-11-13 00:32:18 发布
最新推荐文章于 2023-11-13 00:32:18 发布
阅读量173 收藏
点赞数
文章标签： 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
    评论
红黑树的实现C++代码
07-27
用C++代码实现了一个红黑树，大家可以一起学习学习，有问题也可以直接给我留言
＜map与set的模拟实现＞——《C++高阶》
m0_57859086的博客
08-14 701
——《》C++高阶
学习-＞C++篇十五：红黑树和map,set
u014801954的博客
10-18 726
目录 一 . 红黑树的定义（规则）： 二 . 红黑树是如何保持平衡的？ 插入操作： 情况一：叔叔节点存在且为红色 情况二：叔叔节点不存在或存在且为黑色 三.map和set如何封装？
C++ map的简单实现
WhiteShirtI的博客
05-23 5306
map和set的底层都是通过红黑树来实现的，但并不是原生态的红黑树，而是经过改造后的红黑树。且容器都会在各自的类中添加一些独特的函数来解决各自适配的问题 map和set底层是改造后的红黑树，我们先来看看改造后的红黑树 和普通的红黑树不同的是，在根节点上再加了一个头结点，该结点不是真实的结点，只是一个辅助结点，是为了后面实现红黑树的迭代器而出现的。该header结点的父节点就是真实的根节点，其左孩子是这棵树的最左结点，其右孩子是这棵树的最右节点。 我们现在通过STL源码来简单剖析一下map和set中如何利用
C++手写模板类+迭代器（map二叉树）
ICLiuLi
03-05 1449
有了上一次的经验，这次再来写模板类+迭代器确实是更加得心应手了许多，不过这个里面的问题也比上次的复杂了一些，因为涉及到了排序，和左右子树的链接，除此之外也没有什么好说的了，有问题可以留言 bidirectional_map.h （完整版+注释） #include <iostream> #include <utility> #include <vecto...
【C++】手把手教你实现自己的set 和map
就爱摆烂
03-25 1491
map and set , AVLTree, RBTree 的讲解
红黑树-基于C++实现的红黑树数据结构.zip
03-21
红黑树 红黑树_基于C++实现的红黑树数据结构
map与set的底层大概框架-红黑树
最新发布
04-04
学习map和set的友友们如果对红黑树的底层框架很模糊。 可以借鉴一下本文件中的红黑树。 虽然有些地方写的不够全不够好， 但是基本的迭代器功能都已经实现。其实红黑树的学习主要就是学习它的插入， 最重要的就是...
使用C++实现的rbtree红黑树.zip
03-21
红黑树 使用C++实现的rbtree红黑树
C++红黑树实现过程
09-15
用C++实现的红黑树，没有BUG ，稍微改改就能直接运行了，最优的代码了，拿去研究吧，也没什么可以说的了···
Map (c++实现的简易map)
03-16
vs2013 自己实现的一个简易Map(c++)。
用Ｃ模访写一个c++ map
05-14
用纯c代码模仿写的一个c++ map。底层的数据存储采用的是红黑树，上面为了支持所有的数据类型，写成一个通用的c map，大量的采用了宏函数。这个c map基本上支持所有的数据类型，只是用起来不如c++方便。
C++ 红黑平衡树的实现
07-15
按照红黑平衡树的原理，实现的一个二叉树，key value的模板类，实现了数据的添加和快速的查找等功能
【C++】map与set容器——红黑树底层封装
Pursue quality, not quantity.
04-04 947
map和set的介绍，以及如何用红黑树封装map和set，细节拉满！
C++数据结构 —— 红黑树
weixin_59913110的博客
03-03 4502
enum Corlor //枚举颜色RED,BLACKtemplate //为了方便，使用K模型K _key;{}
【C++】红黑树 --- map/set 底层
YoungMLet的博客
11-13 1132
了解 map/set 底层红黑树的插入！使用红黑树封装 map/set ！
【C++】红黑树（Red Black Tree）
knous
08-04 418
红黑树的一些操作
【C++】红黑树详解（附迭代器以及插入实现），适合初学者
jhao的博客
07-13 2275
红黑树的简单实现附有迭代器实现，代码都有详细解释，适合于初学者和想要理解STL map/set原理的朋友观看。
C++ map的底层实现为什么是红黑树
sinat_31608641的博客
11-12 1194
map的底层原理
c++stl，map和unordered_map
06-28
### 回答1： C++ STL是C++标准库的一部分，包含了许多常用的数据结构和算法，如vector、list、map、set等。STL的设计目的是提供高效、可靠、通用的数据结构和算法，使得程序员可以更加方便地编写高质量的代码。 map和unordered_map是STL中的两种关联容器，它们都可以用于存储键值对。map是一种有序的关联容器，它使用红黑树实现，可以快速地查找、插入和删除元素，但是它的空间复杂度较高。unordered_map是一种无序的关联容器，它使用哈希表实现，可以在常数时间内查找、插入和删除元素，但是它的空间复杂度较低。 在使用map和unordered_map时，需要注意它们的特点和适用场景。如果需要有序地存储键值对，并且需要快速地查找、插入和删除元素，那么应该选择map；如果不需要有序地存储键值对，并且需要在常数时间内查找、插入和删除元素，那么应该选择unordered_map。 ### 回答2： C++ STL（标准模板库）是C++标准库的一部分，提供了一组标准的库函数和容器类，能够帮助C++开发者提高代码复用性，减少代码编写时间。其中，map和unordered_map是STL库中常用的关联容器，用于存储键值对。 map是有序的关联容器，它存储键值对，并且根据键排序，使用红黑树实现，插入/查找/删除操作的时间复杂度均为log(N)。map可以被用于实现数据结构，例如有序映射和堆积。map对于需要手动排序的问题十分实用，因为它会自动维护键值的顺序。 unordered_map是哈希表实现的关联容器，它同样存储键值对，但是不会对键进行排序，插入/查找/删除的平均时间复杂度为常数级别，实际上操作速度更快。一般来说，unordered_map速度更快，但是由于哈希表的不确定性，其效率可能会受到键分布的影响。 两个容器都可以通过类似于数组的方式访问元素，但是map访问方式是map[key]，而unordered_map的访问方式为unordered_map[key]。对于元素的添加，map需要使用insert函数，而unordered_map使用emplace或insert函数均可。 在使用STL中的容器时，选择合适的数据结构非常重要。如果需要存储有序的数据并且希望通过键来快速访问数据，可以选择map。但是，如果只关心快速访问和查找数据，可以选择unordered_map。需要注意的是，在许多情况下，具体的使用场景会影响选择的容器类型。 ### 回答3： C++ STL（Standard Template Library）是C++标准库的一部分，包含了许多模板类、函数和算法，大大提高了C++程序的开发效率。其中，map和unordered_map是两个重要的容器类。 map是一个关联容器，它将键值对映射到一个有序的序列中，其中键是唯一的。map的底层实现是红黑树，因此它具有快速的查找和插入操作。map是按照键的自然顺序进行排序的，默认按照小于号（<）进行比较。如果需要按照其他方式进行排序，可以自定义比较函数。 unordered_map也是一个关联容器，它将键值对映射到一个无序的序列中，其中键是唯一的。unordered_map的底层实现是哈希表，因此它具有快速的查找和插入操作。unordered_map的元素是无序的，因此不能像map那样直接遍历。如果需要按照键的自然顺序进行遍历，可以将unordered_map中的元素复制到一个vector中，然后对vector进行排序。 map和unordered_map都支持以下操作： 1. 插入元素：使用插入函数（insert）或者下标运算符[]来插入元素。 2. 删除元素：使用删除函数（erase）来删除指定位置或者指定键的元素。 3. 查找元素：使用find函数来查找指定键的元素，如果找到了就返回对应元素的迭代器，否则返回尾迭代器。 4. 遍历元素：可以使用迭代器（iterator）来遍历容器中的所有元素。 在使用map和unordered_map时，需要注意以下问题： 1. 如果键是自定义类型，需要重载==运算符和小于号（<）运算符，以便能够正确比较元素。 2. 在使用unordered_map时，需要定义一个哈希函数，以便将元素散列到桶中。 3. 在插入元素时，如果键已经存在，会直接覆盖原有元素。 4. 在删除元素时，需要注意迭代器过期的问题，删除元素后，迭代器可能会失效，不能再使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值