模拟实现STL中map和set容器

最新推荐文章于 2022-09-12 18:09:57 发布
最新推荐文章于 2022-09-12 18:09:57 发布
阅读量155 收藏
点赞数
分类专栏： c++学习之路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuyuchen282828/article/details/103381786
版权

红黑树的迭代器

//红黑树的迭代器
template<class T>
struct RBTreeIterator
{
	typedef RBTreeNode<T>Node;
	typedef RBTreeIterator<T> Self;
public:
	RBTreeIterator(Node* pNode = nullptr)
		:_pNode(pNode)
	{}
	//具有指针操作
	T& operator*()
	{
		return _pNode->_data;//找值
	}
	T* operator->()
	{
		return &(operator*());
	}

	//可以移动
	Self& operator++()
	{
		Increament();
		return *this;
	}
	Self operator++(int)
	{
		Self temp(*this);
		Increament(); //往后走一步
		return temp;
	}
	Self& operator--()
	{
		DeIncreament();
		return *this;
	}
	Self operator--(int)
	{
		Self temp(*this);
		DeIncreament();
		return temp;
	}
	bool operator==(const Self& s)const
	{
		return _pNode == s._pNode;
	}
	bool operator!=(const Self& s)const
	{
		return _pNode != s._pNode;
	}
private:
	void Increament()
	{
		if (_pNode->_pRight)  //右子树存在
		{
			_pNode = _pNode->_pRight;
			while (_pNode->_pLeft)
				_pNode = _pNode->_pLeft;
		}
		else
		{
			//比_pNode大的元素可能在它的双亲中
			Node* pParent = _pNode->_pParent;
			while (_pNode == pParent->_pRight)
			{
				_pNode = pParent;
				pParent = _pNode->_pParent;
			}
			//根结点没有右子树&&迭代器在根结点的位置
			if (_pNode->_pRight!=pParent)
				_pNode = pParent; //把pNode放到双亲的位置
		}
	}
	void DeIncreament()
	{
		if (_pNode->_pParent->_pParent == _pNode&& RED == _pNode->_color)
		{
			_pNode = _pNode->_pRight;
		}
		else if (_pNode->_pLeft)
		{
			//如果左子树存在，应该在左子树中找最大的结点
			_pNode = _pNode->_pLeft;
			while (_pNode->_pRight)
				_pNode = _pNode->_pRight;
		}
		else
		{
			//向上找
			Node* pParent = _pNode->_pParent;
			while (_pNode == pParent->_pLeft)
			{
				_pNode = pParent;
				pParent = _pNode->_pParent;
			}
			//begin不可能再减
			_pNode = pParent;
		}
	}
private:
	Node* _pNode;
};

红黑树的改造

template<class T,class KOFV>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef RBTreeIterator<T> iterator;

public:
	RBTree()
		:_size(0)
	{
		_pHead = new Node;
		_pHead->_pLeft = _pHead;
		_pHead->_pRight = _pHead;
		//构造里已经将双亲给成空
	}
	iterator begin()
	{
		return iterator(_pHead->_pLeft);
	}
	iterator end()
	{
		return iterator(_pHead);
	}

	pair<iterator,bool> Insert(const T&data)
	{
		Node*& pRoot = GetRoot(); //必须以引用的方式进行接受
		Node* pNewNode = nullptr;
		if (nullptr == pRoot) //树为空,创建根结点
		{
			pNewNode = pRoot = new Node(data, BLACK);
			pRoot->_pParent = _pHead;//只有一个结点，head就是根节点的双亲
		}
		else
		{
			//说明树已经不为空了
			//1.按照二叉搜索树的性质找到带插入结点在红黑树的位置
			Node* pCur = pRoot;
			Node* pParent = nullptr;
			while (pCur)
			{
				pParent = pCur;//标记双亲位置
				if (KOFV()(data) < KOFV()(pCur->_data))
					pCur = pCur->_pLeft;
				else if (KOFV()(data) > KOFV()(pCur->_data))
					pCur = pCur->_pRight;
				else
					//相同不插入
					return make_pair(iterator(pCur),false);
			}
			//2. 插入新结点
			pNewNode = pCur = new Node(data);
			if (KOFV()(data) < KOFV()(pParent->_data))
				pParent->_pLeft = pCur;
			else
				pParent->_pRight = pCur;
			//3. 更新双亲位置
			pCur->_pParent = pParent;
			//以上没错
			//4.检测:是否新结点插入后连在一起的红色结点
			while (pParent != _pHead && RED == pParent->_color)
			{
				Node* granderFather = pParent->_pParent;
				if (pParent == granderFather->_pLeft)
				{
					//叔叔结点在右侧
					Node* uncle = granderFather->_pRight;
					//情况一:叔叔结点存在，且为红
					if (uncle && RED == uncle->_color)
					{
						pParent->_color = BLACK;
						uncle->_color = BLACK;
						granderFather->_color = RED;
						pCur = granderFather;
						pParent = pCur->_pParent;
					}
					//以上没问题
					else
					{
						//情况三
						if (pCur == pParent->_pRight) //情况三
						{
							//转变成情况二
							RotateLeft(pParent);
							swap(pParent, pCur);
						}
						//情况二
						pParent->_color = BLACK;
						granderFather->_color = RED;
						RotateRight(granderFather);
					}
					//以上没问题
				}
				else
				{
					//叔叔结点在左侧
					Node* uncle = granderFather->_pLeft;
					//情况一的反情况
					if (uncle && uncle->_color == RED)
					{
						pParent->_color = BLACK;
						uncle->_color = BLACK;
						granderFather->_color = RED;
						pCur = granderFather;
						pParent = pCur->_pParent;
					}
					//以上没问题
					else
					{
						//情况三的反情况
						if (pCur == pParent->_pLeft)	/**/
						{
							//情况三的反情况变成情况二的反情况
							RotateRight(pParent);
							swap(pParent, pCur);
						}
						//情况二反情况处理
						pParent->_color = BLACK;
						granderFather->_color = RED;
						RotateLeft(granderFather);
					}
					//以上没问题
				}
			}
		}
		//5.调整头结点的左右指针域
		//保证根节点是黑色
		++_size;
		pRoot->_color = BLACK;
		_pHead->_pLeft = LeftMost();
		_pHead->_pRight = RightMost();
		return make_pair(iterator(pNewNode), true);
	}

	iterator Find(const T& data)const
	{
		Node* pCur = _pHead->_pParent;
		while (pCur)
		{
			if (KOFV()(data) == KOFV()(pCur->_data))
				return iterator(pCur);
			else if (KOFV()(data) < KOFV()(pCur->_data))
				pCur = pCur->_pLeft;
			else
				pCur = pCur->_pRight;
		}
		return end();
	}

	void InOrder()
	{
		_InOrder(GetRoot());
	}

	//检测红黑树
	bool IsValidRBTree()
	{
		Node* pRoot = GetRoot();
		if (nullptr == pRoot)
			return true;
		if (pRoot->_color != BLACK)
		{
			cout << "违反性质2：根结点颜色必须为黑色" << endl;
			return false;
		}
		//获取一条路径中结点的个数
		size_t blackCount = 0; //基准值
		Node* pCur = pRoot;
		while (pCur)
		{
			if (pCur->_color == BLACK)
				blackCount++;
			pCur = pCur->_pLeft;
		}
		size_t pathBlack = 0; //每条路径中的黑色结点个数
		return _IsValidRBTree(pRoot, blackCount, pathBlack);
	}

	bool Empty()const
	{
		return nullptr = _pHead->_pParent;
	}
	size_t Size()const
	{
		return _size;
	}
protected:
	bool _IsValidRBTree(Node* pRoot, size_t blackCount, size_t pathBlack)
	{
		if (nullptr == pRoot)
			return true;
		if (pRoot->_color == BLACK)
			pathBlack++;
		//检测性质3
		Node* pParent = pRoot->_pParent;
		if (pParent != _pHead && pParent->_color == RED&&pRoot->_color == RED)
		{
			cout << "违反性质3:不能有连在一起的红色结点" << endl;
			return false;
		}

		if (nullptr == pRoot->_pLeft&&nullptr == pRoot->_pRight)
		{
			//一条路径到叶子
			if (blackCount != pathBlack)
			{
				cout << "违反了性质4：每条路径中黑色结点个数必须相同" << endl;
				return false;
			}
		}
		return _IsValidRBTree(pRoot->_pLeft, blackCount, pathBlack) &&
			_IsValidRBTree(pRoot->_pRight, blackCount, pathBlack);
	}
	Node* LeftMost()
	{
		//得到根节点
		Node* pRoot = GetRoot();
		if (nullptr == pRoot)
			return _pHead;
		Node* pCur = pRoot;
		//找到最左侧结点
		while (pCur->_pLeft)
			pCur = pCur->_pLeft;
		return pCur;
	}
	Node* RightMost()
	{
		//得到根节点
		Node* pRoot = GetRoot();
		if (nullptr == pRoot)
			return _pHead;
		Node* pCur = pRoot;
		//找到最右侧结点
		while (pCur->_pRight)
			pCur = pCur->_pRight;
		return pCur;
	}

	void RotateLeft(Node* pParent)
	{
		Node* pSubR = pParent->_pRight;
		Node* pSubRL = pSubR->_pLeft;

		pParent->_pRight = pSubRL;
		if (pSubRL)
			pSubRL->_pParent = pParent;

		pSubR->_pLeft = pParent;
		Node* pPParent = pParent->_pParent;
		pParent->_pParent = pSubR;
		pSubR->_pParent = pPParent;

		if (pPParent == _pHead)
			GetRoot() = pSubR;
		else
		{
			if (pPParent->_pLeft == pParent)
				pPParent->_pLeft = pSubR;
			else
				pPParent->_pRight = pSubR;
		}
	}
	void RotateRight(Node* pParent)
	{
		Node* pSubL = pParent->_pLeft;
		Node* pSubLR = pSubL->_pRight;

		pParent->_pLeft = pSubLR;
		if (pSubLR)
			pSubLR->_pParent = pParent;

		pSubL->_pRight = pParent;
		Node* pPParent = pParent->_pParent;
		pParent->_pParent = pSubL;
		pSubL->_pParent = pPParent;

		//pParent是根结点
		if (pPParent == _pHead)
			GetRoot() = pSubL;
		else
		{
			//非根结点
			if (pPParent->_pLeft == pParent)
				pPParent->_pLeft = pSubL;
			else
				pPParent->_pRight = pSubL;
		}
	}

	Node*& GetRoot()  //head是new出来的，head存在parent一定存在，按引用方式返回没有问题
	{
		//得到根节点，也就是头结点的下一个结点
		return _pHead->_pParent;
	}

	void _InOrder(Node* pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
			cout << pRoot->_data << " ";
			_InOrder(pRoot->_pRight);
		}
	}
private:
	Node* _pHead;
	size_t _size; //记录红黑树中有效结点的个数
};
struct KeyValue
{
	int operator()(int data)
	{
		return data;
	}
};

模拟实现map和set

map<key,value>----比较方式:键值对中的key
set:key ----比较方式:直接用其元素比较

map模拟实现
#pragma once
#include"RBTree.h"

namespace bite
{
	//只需要封装一个红黑树
	template<class K, class V>
	class map
	{
		typedef pair<K, V> ValueType;

		struct KeyOfValue
		{
			const K& operator()(const ValueType & data)
			{
				return data.first;
			}
		};

	public:
		//编译器有可能将iterator当成静态成员变量来处理
		typename typedef RBTree<ValueType, KeyOfValue>::iterator iterator;
		//明确的告诉编译器iterator 时红黑树中的一种类型
	public:
		map()
			:_t()
		{}
		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		pair<iterator, bool> insert(const ValueType&data)
		{
			return _t.Insert(data);
		}
		size_t size()const
		{
			return _t.Size();
		}
		bool Empty()const
		{
			return _t.Empty();
		}

		iterator find(const K& key)
		{
			return  _t.Find(make_pair(key,V()));
		}

		V& operator[](const K& key)
		{
			return (*(_t.Insert(ValueType(key, V()))).first).second;
		}
	private:
		RBTree<ValueType,KeyOfValue> _t;
	};
}

#include<string>
#include<iostream>
using namespace std;
void TestMap()
{
	bite::map<std::string, std::string>m;
	m.insert(pair<std::string,std::string>("2222","11111"));
	m.insert(make_pair("1111","1111"));

	m["0000"] = "0000";
	cout << m.size() << endl;
	for (auto e : m)
		cout << e.first << " " << e.second << endl;
	cout << endl;
}

在这里插入图片描述

set模拟实现
namespace bite
{
	//只需要封装一个红黑树
	template<class K>
	class set
	{
		typedef K ValueType;

		struct KeyOfValue
		{
			const K& operator()(const ValueType & data)
			{
				return data;
			}
		};

	public:
		//编译器有可能将iterator当成静态成员变量来处理
		typename typedef RBTree<ValueType, KeyOfValue>::iterator iterator;
		//明确的告诉编译器iterator 时红黑树中的一种类型
	public:
		set()
			:_t()
		{}
		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		pair<iterator, bool> insert(const ValueType&data)
		{
			return _t.Insert(data);
		}
		size_t size()const
		{
			return _t.Size();
		}
		bool Empty()const
		{
			return _t.Empty();
		}

		iterator find(const K& key)
		{
			return  _t.Find(key);
		}

	private:
		RBTree<ValueType, KeyOfValue> _t;
	};
}
#include<string>
#include<iostream>
using namespace std;
void TestSet()
{
	bite::set<std::string>m;
	m.insert("2222");
	m.insert("11111");
	m.insert("11111");
	
	cout << m.size() << endl;
	for (auto e : m)
		cout << e << endl;
	cout << endl;
}
阳光丿洒脱
关注
专栏目录
map和set容器
Rinki123456的博客
08-07 533
用来表示一一对应关系的一种结构，该结构只包含了两个成员变量key和value，key表示键值，value表示与key所对应的信息，比如英汉互译的字典，找到一个英语单词必定存在一个与之对应的翻译，每个单词和翻译之间是一一对应的。查询当前容器有多少个键值是key的数据，但由于在map中key值是独立的，因此count的结果只能是0 / 1。通过介绍我们可以发现，如果键值key在map中存在时，则会返回其键值对应的value的引用，关联式容器也是用来存储数据的，与序列式容器不同的是，里面存储的是。...
＜stl系类＞ map和set详解，掌握stl容器从现在开始
weixin_59371851的博客
08-25 688
哈喽，小伙伴们大家好。今天我们继续来学习STL容器，今天我将主要介绍map和set的使用。话不多说，拿好小本本，我们赶快开始吧。一、关联式容器1、关联式容器概念在之前我们接触过STL的部分容器，比如vector，deque，list。这些容器统称为序列式容器，底层为线性结构，存储的是元素本身。那什么是关联式容器呢？关联式容器也是用来存储数据的，与序列式容器不同的是，关联式容器中存储的结构的键值对，有助于数据检索。...
红黑树
05-11 940
红黑树         红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由Rudolf Bayer发明的，他称之为"对称二叉B树"，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的
Map 和 Set 容器
天行 Luke Skywalker
12-28 640
<br /> <br />Map和Set 所谓 关联容器 Associative Container 与顺序容器（Sequential Container）的本质区别在于：<br /> <br />关联容器是通过键（key）存储和读取元素的，而顺序容器则通过元素在容器中的位置顺序存储和访问元素。<br /> <br />map的元素是“键-值”对的二元组形式：键用作元素在map中的索引，而值 则表示所存储和读取的数据。<br />set的元素包含一个键，并有效地支持关于某个键是否存在的查询。<br />ma
容器——map和set
波风水门的博客
05-18 359
目录关联式容器键值对概念接口介绍 关联式容器 序列式容器：在前面我们学习了 STL 中的string、vector、list、deque等容器，而这些容器因为其底层是线性序列的数据结构，里面存储的是元素本身，所以我们将它们称之为序列式容器； 关联式容器：关联式容器也是用来存储数据的，与序列式容器不同的是，其里面存储的不单单是数据本身，而是存储了关键码和数据的<key, value>结构的键值对，该种容器在数据检索时比序列式容器效率更高； 键值对 概念 概念：用来表示具有一 一对应关系的一种
C++ map 和 set容器
ac@zhui的博客
03-16 205
转载地址：http://blog.csdn.net/bingtang_blog/article/details/52730530 因为代码注释比较详尽，也就不多言语啦 map #include&lt;iostream&gt; #include&lt;map&gt; using namespace std; int main(){ //map声明，加入有文件map map...
红黑树模拟实现STL中的map与set（附详细代码）
zhao_leilei的博客
01-26 721
文章目录1.红黑树的迭代器2.改造红黑树3.map的模拟实现4.set的模拟实现 1.红黑树的迭代器 迭代器的好处是可以方便遍历，使数据结构的底层实现与用户透明。如果想要给红黑树增加迭代器，需要考虑以下问题： begin()与end() STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？能
【手撕STL】map和set
AI_ELF的博客
07-09 806
这里写目录标题setset的使用举例map三级目录 set set文档介绍 set是按照一定次序存储元素的容器 在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。 在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。 set容器通过key访问单个元素的速度通常比unordered_set容器慢，但它们允许根据顺序对子集进行直接迭
深入解析C++ STL中的常用容器
09-05
在STL中，容器是用于存储和管理数据的主要工具。本篇文章将深入解析C++ STL中的一些常用容器，包括顺序性容器、关联容器以及容器适配器。 1. 顺序性容器 - (1) vector `vector` 是一种动态数组，内存中存储是连续...
一篇带你了解STL-set和map的基本使用
weixin_45599288的博客
01-09 1193
set和map关联式容器键值对树形结构的关联式容器setset的构造set的插入和迭代器set的容量set的删除multisetmap二级标题二级标题二级标题二级标题三级目录 关联式容器 之前遇到的vector,list,deque这些容器统称为序列式容器，因为其底层为线性序列的数据结构，里面存储的是元素本身。 关联式容器： 用来存储数据的，与序列式容器不同的是，其里面存储的是<key, value>结构的键值对，在 数据检索时比序列式容器效率更高。 键值对 用来表示具有一一对应关系的一种结
STL中map用法以及示例
热门推荐
凉_白开的博客
04-09 3万+
STL中map用法以及示例 STL中map用法以及示例 map简介 使用map 数据的插入 第一种：用insert函数插入pair数据 第二种：用insert函数插入value_type数据 第三种：用数组方式插入数据 map的大小 数据的遍历 第一种：应用前向迭代器 第二种：应用反相迭代器 第三种，用数组的形式 查找并获取map中的元素 find函数 lower_bound函数 和...
set和map容器
莱尼的博客
02-12 267
set和map都是用二叉搜索树来维护的容器 1.set相关操作 2.map相关操作
set与map容器
m0_60492395的博客
09-12 176
map与set初步理解
【STL】模拟实现STL中set容器
宫瑞阳的博客
03-01 222
模拟实现STL中set容器
set和map容器——STL
qq_51399192的博客
03-31 1578
文章目录pair对组创建关联式容器(set)插入和删除大小操作赋值操作独有：查找操作set不允许插入相同的值，multiset允许插入相同的值从大到小排列对于自定义的数据类型关联式容器（map）插入和删除大小操作赋值操作独有：查找操作从大到小排列 pair对组 创建 //第一种方法：构造函数 pair<string,int> p ("Tom",10); cout<<"姓名："<<p.first<<" "<<"年龄："<<p.second
STL之map实现（一）
V的博客
11-22 1646
map其实就是一个映射，想象你在使用新华字典的时候，输入一个单词，就能得到这个单词的意思，这样就形成了一个映射。 为了实现map,你需要有类和对象，虚函数，模板，pair类型基础 首先，介绍一下模板，看下面的函数(重复做同样事情的函数，只是类型不一样) int sum(int a,int b) {   return a+b; } float sum(float
map与set容器的使用
南山南，北海北
01-07 437
map、set容器的应用(文本中关键词的查询) 1.查询程序设计要求：   读入指定的文本文档，搜索文档中的关键字，显示出文档中关键字所在行号与对应行的内容。 2.数据容器及关系的选择：   行号采用set容器存储：确保输出时以升序形式输出，当一行中有多个关键词时，不重复输出。   每行包含单词分别与对应行号以map>容器关联：   设计的类TextQuery中包含两个
STL—string容器使用及模拟实现
weixin_42357849的博客
05-12 151
一. string介绍。 C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP（面向对象的程序设计）的思想，而且底层空间需要用户自己管理，稍不留神可能还会发生越界访问。 string类： string是表示字符串的字符串类。 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。 string在底层实际是：basic_string模板类的别名，typedef basic_s
C++入门：STL_容器_vector的模拟实现
leesunl的博客
04-09 149
代码 #include <iostream> using namespace std; namespace bit { template <class _Ty> class vector { public: typedef _Ty* iterator; public: vector() :_First(nullptr), _Last(nullptr),_End(nullptr) {} ~vector() { delete _First;
C++ STL实战：从容器到算法全面示例
本资源主要涵盖了C++中的所有容器的使用例子，包括但不限于vector、deque、list、set、multiset、map、multimap、stack、queue以及priority_queue等。 首先，我们来看一下容器`vector`。`vector`是最常用的一种动态...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值