【C++修炼之路】21.红黑树封装map和set

最新推荐文章于 2023-06-02 17:29:53 发布
最新推荐文章于 2023-06-02 17:29:53 发布
阅读量677 收藏 2
点赞数 6
分类专栏： C++ 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NEFUT/article/details/129122164
版权

在这里插入图片描述
每一个不曾起舞的日子都是对生命的辜负

红黑树封装map和set

前言

上一节中，说到了红黑树的实现，并且已经知道map和set的底层共用了同一套红黑树的结构。但这样就会出现一个问题，map的数据域和set不一样，比较大小的方式自然也就不一样。因此上一篇中的红黑树还需要做出一些改变才能用来实现map和set。

一.改良红黑树的数据域结构

对于如何设计针对map、set的红黑树结构，看源码的实现无疑是最好的方式：

image-20230216201230246

对于源码的实现，我们知道set是<k,k>的键值对，但是在使用时却只显示一个k，map是<k,value>的键值对，通过观察源码发现，map的节点结构为rb_tree<key_type, value_type>，但发现其设计方式很特殊，value_type是pair<const Key, T>的重命名，也就是说，map节点结构的key_type并不作为数据域，value_type单一类型就充当了数据域，而key_type实际上可以充当查找的作用。因此，下面改良红黑树就采用这种方式：一个类型T作为结点的全部数据域。

1.1 改良后的结点

enum Color//颜色采用枚举，但STL库采用的是特殊的bool值，后续会看
{
	RED,//0
	BLACK//1
};

template<class T>
struct RBTreeNode
{
	T _data;
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	Color _col;

	RBTreeNode(const T& data)
		:_data(data)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}

};

与之前的双参数<class K, class V>相比，改良之后的T作为了全部的数据域，即T也可以代表pair类型。

1.2 改良后的类

在前言中提到，比较方式也是一个头疼的问题，这个时候就可以自己封装一个比较方式，即以仿函数的形式进行比较。

由于只有比较方式进行了改变，因此除了insert其他的都没有变化，所以下面只展示insert

enum Color//颜色采用枚举，但STL库采用的是特殊的bool值，后续会看
{
	RED,//0
	BLACK//1
};

template<class T>
struct RBTreeNode
{
	T _data;
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	Color _col;

	RBTreeNode(const T& data)
		:_data(data)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}

};

// set->RBTree<K, K, SetKeyOfT> _t;
// map->RBTree<K, pair<const K, V>, MapKeyOfT> _t;
template<class K, class T, class KeyOfT>//新增的KeyOfT就是仿函数
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	bool Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;//根节点为黑色
			return true;
		}

		KeyOfT kot;//仿函数

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(data);
		cur->_col = RED;//重要，插入的结点初始化成红色
		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		while (parent && parent->_col == RED)//如果父亲的颜色为红，才需要去处理
		{
			Node* grandfather = parent->_parent;//找到祖父才能找到叔叔
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//看叔叔颜色
				//情况1：uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2或3：不用考虑叔叔的问题，即叔叔为空还是为黑
				{
					if (cur == parent->_left)//情况2
					{
						//     g
						//   p
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else//情况3
					{
						//     g
						//   p
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else//与上述代码的左右反过来了而已，步骤一样但左右相反。
			{
				Node* uncle = grandfather->_left;
				//情况1
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2和3
				{
					//  g
					//     p
					//        c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//  g
						//     p
						//   c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
			}
		}

		_root->_col = BLACK;
		return true;
	}
private:
    	Node* _root = nullptr;
};

二. 封装的set和map

以仿函数封装就可以完成比较。

2.1 set.h

#pragma once
#include"RBTree.h"

namespace cfy
{
	template<class K>
	class set
	{
		struct SetKeyOfT//仿函数
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		bool insert(const K& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};

	void test_set()
	{
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };

		set<int> s;
		for (auto e : a)
		{
			s.insert(e);
		}
	}
}

2.2 map.h

#pragma once
#include"RBTree.h"
namespace cfy
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT//仿函数
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};

	public:
		bool insert(const pair<const K, V>& kv)
		{
			return _t.Insert(kv);
		}

	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};


	void test_map()
	{
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		map<int, int> m;
		for (auto e : a)
		{
			m.insert(make_pair(e, e));
		}
	}
}

三. 迭代器

需要将有关迭代器的功能都封装起来，这在之前的vector、list模拟实现时已经了解过。对于map和set的迭代器，重要的函数重载就是++和–了。为了map和set能够共用这一套迭代器，因此将其封装在RBTree里。

3.1 迭代器封装

迭代器的好处是可以方便遍历，是数据结构的底层实现与用户透明。如果想要给红黑树增加迭代器，需要考虑以前问题：begin()与end()
STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？
能否给成nullptr呢？答案是行不通的，因为对end()位置的迭代器进行–操作，必须要能找最后一个元素，此处就不行，因此最好的方式是将end()放在头结点的位置：image-20230218183550811

但由于我们上一届中设计的RBTree没有头结点这个结构，因此我们也就不与STL的实现方式完全一样，end()就直接设置为nullptr。

//迭代器
template<class T>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T> Self;//迭代器类进行typedef
	Node* _node;

	__RBTreeIterator(Node* node)
		:_node(node)
	{}

	T& operator*()
	{
		return _node->_data;
	}

	T* operator->()
	{
		return &_node->_data;
	}
    //迭代器++
    //迭代器--
    //上面两个都拿出来在下面
	
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}

};

一. 对于++，有这么两种选择：

  • 如果右树不为空，则找到右树的最左节点。
  • 如果右树为空，则找到孩子是父亲的左孩子的那个祖先。
Self& operator++()//迭代器返回的还是迭代器
{
    if (_node->_right)//1.右不为空，找到右子树的最左节点
    {
        Node* min = _node->_right;
        while (min->_left)
        {
            min = min->_left;
        }
        _node = min;
    }
    else//2.右为空，则找祖先：孩子是父亲的左的那个祖先
    {
        Node* cur = _node;
        Node* parent = cur->_parent;
        while (parent && cur == parent->_right)
        {
            cur = cur->_parent;
            parent = parent->_parent;
        }

        _node = parent;
    }
    return *this;
}

二. 对于–，有这么两种选择：（事实上思路就是与++相反）

  • 如果左树不为空，则找到左树的最右结点（也就是最大结点)。
  • 如果左树为空，则找到孩子是父亲的右孩子的那个祖先。
Self& operator--()
{
    if (_node->_left)
    {
        Node* max = _node->_left;
        while (max->_right)//max一定存在，因此不需要写出max条件
        {
            max = max->_right;
        }
        _node = max;
    }
    else
    {
        Node* cur = _node;
        Node* parent = _node->_parent;
        while (parent && cur == parent->_left)
        {
            cur = cur->_parent;
            parent = parent->_parent;
        }
        _node = parent;
    }
    return *this;
}

3.2 const迭代器

如果是const迭代器，那可以在迭代器类中多加上两个模板参数：T&, T*偏特化，当然实际上是Ref，Ptr的全特化；由于set不能修改，因此set的普通迭代器和const迭代器都应该是const类型，但map的value可以修改，因此我们就需要在RBTree中把普通迭代器和const迭代器均实现出来。此外，对于map来讲，需要实现operator[]的重载，因此我们插入函数返回的值也应该从bool变成pair类型，这样才便于在operator[]重载中进行操作。由于代码繁琐，且需要处理一些细节问题，因此代码的注释将会就那些进行解释，看下面代码就可以了。

四.完整代码实现

提示：需要注意细节问题，如普通迭代器可以赋值给const迭代器的原理。

4.1 RBTree.h

#pragma once

enum Color//颜色采用枚举，但STL库采用的是特殊的bool值，后续会看
{
	RED,//0
	BLACK//1
};

template<class T>
struct RBTreeNode
{
	T _data;
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	Color _col;

	RBTreeNode(const T& data)
		:_data(data)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
	{}

};

//迭代器
// class< T, T&, T*>
template<class T, class Ref, class Ptr>
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T, Ref, Ptr> Self;//迭代器类进行typedef
	//如果Ref和Ptr都是非const，则下面与上面没区别，但如果是const，则下面仍是非const，因此可以const迭代器可以赋值给非const就是因为下面的这个，就是一个构造
	typedef __RBTreeIterator<T, T&, T*> iterator;//满足普通迭代器可以赋值给const迭代器
	Node* _node;


	__RBTreeIterator(Node* node)
		:_node(node)
	{}

	// 普通迭代器的时候，他是拷贝构造
	// const迭代器的时候，他是构造，支持用普通迭代器构造const迭代器
	__RBTreeIterator(const iterator& s)//加上这个，就满足普通迭代器赋值给const迭代器
		:_node(s._node)
	{}

	Ref operator*()
	{
		return _node->_data;
	}

	Ptr operator->()
	{
		return &_node->_data;
	}

	Self& operator++()//迭代器返回的还是迭代器
	{
		if (_node->_right)//1.右不为空，找到右子树的最左节点
		{
			Node* min = _node->_right;
			while (min->_left)
			{
				min = min->_left;
			}
			_node = min;
		}
		else//2.右为空，则找祖先：孩子是父亲的左的那个祖先
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}

			_node = parent;
		}
		return *this;
	}
	Self& operator--()
	{
		if (_node->_left)
		{
			Node* max = _node->_left;
			while (max->_right)//max一定存在，因此不需要写出max条件
			{
				max = max->_right;
			}
			_node = max;
		}
		else
		{
			Node* cur = _node;
			Node* parent = _node->_parent;
			while (parent && cur == parent->_left)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	bool operator!=(const Self& s) const
	{
		return _node != s._node;
	}

};

// set->RBTree<K, K, SetKeyOfT> _t;
// map->RBTree<K, pair<const K, V>, MapKeyOfT> _t;
template<class K, class T, class KeyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef __RBTreeIterator<T, T&, T*> iterator;
	typedef __RBTreeIterator<T, const T&, const T*> const_iterator;

	iterator begin()
	{
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}

		return iterator(left);
	}

	iterator end()
	{
		return iterator(nullptr);
	}


	const_iterator begin() const
	{
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}

		return const_iterator(left);
	}

	const_iterator end() const
	{
		return const_iterator(nullptr);
	}


	pair<iterator, bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;//根节点为黑色
			return make_pair(iterator(_root), true);
		}

		KeyOfT kot;//仿函数

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return make_pair(iterator(cur), false);
			}
		}

		cur = new Node(data);
		Node* newnode = cur;//加上这个是为了pair返回值时return的时候需要返回，因为cue会变，因此记录一下这个结点
		cur->_col = RED;//重要，插入的结点初始化成红色
		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		while (parent && parent->_col == RED)//如果父亲的颜色为红，才需要去处理
		{
			Node* grandfather = parent->_parent;//找到祖父才能找到叔叔
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//看叔叔颜色
				//情况1：uncle存在且为红
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2或3：不用考虑叔叔的问题，即叔叔为空还是为黑
				{
					if (cur == parent->_left)//情况2
					{
						//     g
						//   p
						// c
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else//情况3
					{
						//     g
						//   p
						//     c
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else//与上述代码的左右反过来了而已，步骤一样但左右相反。
			{
				Node* uncle = grandfather->_left;
				//情况1
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else//情况2和3
				{
					//  g
					//     p
					//        c
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//  g
						//     p
						//   c
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
				}
			}
		}

		_root->_col = BLACK;
		return make_pair(iterator(newnode), true);

	}

	//旋转代码和AVL一样，只是去掉了平衡因子
	void RotateL(Node* parent)//左单旋
	{
		//1.记录subR, subRL
		Node* subR = parent->_right;
		Node* subRL = subR->_left;


		parent->_right = subRL;
		if (subRL)//subRL不为空则需要连接到parent
		{
			subRL->_parent = parent;
		}

		Node* ppNode = parent->_parent;//记录保存
		subR->_left = parent;
		parent->_parent = subR;

		if (ppNode == nullptr)//说明根节点变化
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else//如果是局部子树
		{
			//判断ppNode之前是左连接还是右连接
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}

	}

	void RotateR(Node* parent)//右单旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}

		Node* ppNode = parent->_parent;
		subL->_right = parent;
		parent->_parent = subL;

		if (ppNode == nullptr)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
	}

	void Inorder()
	{
		_Inorder(_root);
	}

	bool IsBalance()//检查是否为红黑树结构
	{
		if (_root == nullptr)
		{
			return true;
		}

		if (_root->_col != BLACK)
		{
			return false;
		}

		int ref = 0;
		Node* left = _root;
		while (left)
		{
			if (left->_col == BLACK)
			{
				++ref;
			}

			left = left->_left;
		}
		//遍历这棵树，就好了，检查是否存在连续的红结点。
		//检查父亲，因为孩子不一定有，但是一定有父亲
		return Check(_root, 0, ref);
	}

private:
	bool Check(Node* root, int blackNum, int ref)
	{
		if (root == nullptr)
		{
			if (blackNum != ref)
			{
				cout << "违反规则：一条路径上的黑色节点数量不同" << endl;
				return false;
			}
			return true;
		}

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "违反规则，出现连续红色结点" << endl;
		}
		if (root->_col == BLACK)
		{
			++blackNum;
		}
		return Check(root->_left, blackNum, ref)
			&& Check(root->_right, blackNum, ref);
	}

	void _Inorder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_Inorder(root->_left);
		cout << root->_kv.first << ":" << root->_kv.second << endl;
		_Inorder(root->_right);
	}
	Node* _root = nullptr;
};

4.2 set.h

#pragma once
#include"RBTree.h"

namespace cfy
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		//加上typename是由于没有实例化的模板不能进行typedef。由于不能修改，因此均用const
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator iterator;
		typedef typename RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;

		iterator begin() const
		{
			return _t.begin();//_t.begin()是普通迭代器，iterator是const,因此需要修改
		}

		iterator end() const
		{
			return _t.end();
		}

		pair<iterator, bool> insert(const K& key)
		{
			//直接return会造成const与非const的类型不匹配
			//因为set的iterator默认就是const，但return的并不是const
			//因此需要如下修正：
			pair<typename RBTree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(key);
			return pair<iterator, bool>(ret.first, ret.second);
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};

	void test_set()
	{
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };

		set<int> s;
		for (auto e : a)
		{
			s.insert(e);
		}
		set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			//*it += 10;//set这里不能被修改，因此const迭代器统一
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto& e : s)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

4.3 map.h

#pragma once
#include"RBTree.h"
namespace cfy
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<const K, V>& kv)
			{
				return kv.first;
			}
		};

	public:

		//加上typename是由于没有实例化的模板不能进行typedef。
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;

		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}

		const_iterator begin() const
		{
			return _t.begin();
		}
		const_iterator end() const
		{
			return _t.end();
		}

		pair<iterator, bool> insert(const pair<const K, V>& kv)
		{
			return _t.Insert(kv);
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));
			return ret.first->second;
		}
	private:
		RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};


	void test_map()
	{
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
		map<int, int> m;
		for (auto e : a)
		{
			m.insert(make_pair(e, e));
		}
		map<int, int>::iterator it = m.begin();
		while (it != m.end())
		{
			//it->first++; 经过const就不能修改了
			it->second++;//允许被修改
			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;

		//map统计水果操作的次数
		string arr[] = { "苹果", "西瓜", "香蕉", "草莓", "西瓜",
		"苹果", "苹果","西瓜","苹果",  "香蕉", "苹果", "香蕉" };
		map<string, int> countMap;
		for (auto& e : arr)
		{
			countMap[e]++;
		}
		for (const auto& kv : countMap)//注意加引用，不给就是拷贝构造，代价大
		{
			cout << kv.first << ":" << kv.second << endl;
		}

	}
}

4.4 Test.cpp

#include<iostream>
#include<map>
#include<set>
using namespace std;
#include"RBTree.h"
#include"Map.h"
#include"Set.h"
int main()
{
	cfy::test_set();
	cfy::test_map();
	return 0;
}

image-20230218213352640

每天都要进步呀~
关注
  • 6
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
const T 到const *&T的转换
勤思阁
04-24 1291
C++中关于const T*&的解释问题
红黑树封装 map/set 及其迭代器(C++)
Brant_zero的博客
11-26 2027
使用红黑树封装map/set，并实现map/set的迭代器，支持成员访问、解引用、下标访问操作符++、-- 等功能.
【map和set的封装】
m0_68872612的博客
06-02 628
STL如何只用一颗红黑树就封装出了map和set?
map&set的封装
凡事都是靠练习
08-28 544
在模拟实现了红黑树后，以红黑树为底层结构对map和set进行封装
封装map方法
qq_44473483的博客
07-05 1133
map特性： 1.参数一为回调函数，回调函数里面有三个参数，数组元素，下标和数组，参数二为回调函数的this指向。默认this指向全局。 2.对稀缺数组跳过空元素，不进行处理。 3.返回新数组。 // map拥有两个参数，第一个是回调函数，第二个是this指向 function selfMap(fn, context) { // 拿到数组 let arr = Array.prototype.slice.call(this) // 创建一个新的空数组进行存储 let mapArr = [] // 遍
使用C++实现的rbtree红黑树.zip
03-21
红黑树（Red-Black Tree）是一种自平衡的二叉...红黑树广泛应用于各种数据结构和算法中，如STL中的map和set容器，以及数据库索引等场景。理解和掌握红黑树的原理及C++实现，对于提升编程能力和解决实际问题大有裨益。
红黑树-基于C++实现的红黑树数据结构.zip
03-21
例如，在C++标准模板库(STL)中，`std::set`和`std::map`就是基于红黑树实现的。 在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `...
map和set的模拟实现
最新发布
06-06
在IT领域，数据结构是编程的基础，...总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在实际项目中构建高效的数据处理机制。
c++容器list、vector、map、set区别与用法详解
12-17
c++容器list、vector、map、set区别 list 封装链表，以链表形式实现，不支持[]运算符。 对随机访问的速度很慢(需要遍历整个链表)，插入数据很快(不需要拷贝和移动数据，只需改变指针的指向)。 新添加的元素，...
C++红黑树实现过程
09-15
在实际应用中，红黑树常用于实现STL中的`std::map`和`std::set`，以及内存管理的哈希表等数据结构，因为它提供了高效的查找、插入和删除操作。在C++中，理解和实现红黑树可以帮助开发者深入掌握数据结构和算法，提升...
js封装的Map集合，用法与java一致
04-20
js封装的Map集合，用法与java一致，js封装的Map集合，用法与java一致
js封装Map集合
08-08
项目需要 像Java一样用js自己封装了一个Map集合 希望和大家一起分享
【C++、数据结构】封装map和set（用红黑树实现）
上上谦. 的博客
02-05 912
在这之前我们学习了红黑树的模拟实现，学习了如何使用map和set，同时我们也了解到，map和set底层都是用红黑树来实现的，本文我们就要自己动手封装一下map和set这两大容器，用我们之前学的红黑树来实现一下……🙋 🙋 🙋 🙋 🙋前情回顾：手撕红黑树👉传送门前情回顾：map和set👉传送门//上层维度的一个泛型 template < class T > struct RBTreeNode {T _data;//数据 Colour _col;} };
Map数据封装
weixin_44962939的博客
06-16 293
1、Map封装数据库数据 @Service public class ItemCatServiceImp implements ItemCatService{ @Autowired private ItemCatMapper itemCatMapper; public Map<Integer,List> getMap(){ Map<Integer,List>map=new HashMap<Integer,List>(); Listlist=itemCatMapper.s
c++——map和set的封装
Britney_dark的博客
11-20 772
如果结果不如你所愿，就在尘埃落定前奋力一搏！
map方法学习，封装函数--实现Array.prototype.map()的功能
郭召的博客
05-14 3074
这个方法还是很有使用价值的，可以省下循环的步骤，处理数组中的每个元素，同时返回一个新的数组。我使用闭包封装了一个方法来实现类似的功能。 Array.prototype.map( )方法 首先看一下Array.prototype.map()方法 map() 方法创建一个新数组，其结果是该数组中的每个元素调用一个提供的函数。 map 方法会给原数组中的每个元素都按顺序调用一次 callback 函数。
参数封装Map PageData
ＢabyＦace゛‐尐蔡。的博客
04-12 310
package com.company.busi.tzbldpc.action;import java.util.Collection;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Set;import javax.servlet.http.HttpServletRe...
MyBatis-结果集封装map和pojo
@siye
01-13 1252
使用map存储结果集 使用规范 原则上,所有的结果集都可以存储到map 但使用map存储,会大大降低阅读性 mapper文件中使用map存储结果的参考&lt;select id="xxx" resultType="map"&gt; ... &lt;/select&gt; 测试...
BeanUtils将map直接封装到对象中
qq_3775566111的博客
11-26 7866
需求是要将表单提交的数据封装到一个对象中 对象order public class Order { private String oId; private Date orderTime; private double total; private int state; private String address; pri
C++ map set 红黑树
07-28
C++中的map和set容器都是基于红黑树实现的。 红黑树是一种自平衡的二叉搜索树，它通过对节点进行染色来满足一定的性质，从而保持树的平衡。红黑树的性质包括： 1. 每个节点只能是红色或黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL节点）都是黑色。 4. 如果一个节点是红色，则它的两个子节点都是黑色。 5. 从任意节点到其每个叶子节点的路径上，黑色节点的数量相同。 基于红黑树实现的map容器是一种有序的关联容器，它存储键值对，并根据键的顺序进行排序。每个键值对在map中唯一，且按照键进行升序排列。 基于红黑树实现的set容器是一种有序的集合容器，它存储唯一的元素，并按照元素的顺序进行排序。 使用map和set可以实现高效的查找、插入和删除操作，时间复杂度为O(logN)，其中N为容器中元素的个数。同时，由于基于红黑树的特性，这两个容器还能提供一些额外的操作，例如查找某个区间内的元素。 你可以使用C++标准库中的<map>和<set>头文件来使用这两个容器。希望这能回答你的问题！如果还有其他问题，请继续提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

每天都要进步呀~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值