使用红黑树简单实现Set与Map容器

已于 2023-04-09 16:46:53 修改
阅读量44 收藏
点赞数 1
文章标签： 算法 数据结构 c++
于 2023-04-07 18:46:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48937110/article/details/130018437
版权

文章目录

1.AVL树的简单实现

#pragma once 

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode* _left;
	AVLTreeNode* _right;
	AVLTreeNode* _parent;

	int _buf;//平衡因子  balance factor: 0,1,-1
	pair<K, V> _kv;
public:
	AVLTreeNode(const pair<K,V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_buf(0)
		,_kv(kv)
	{}
};
template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	
	AVLTree()
		:_root(nullptr)
	{

	}
	//拷贝构造和赋值需要实现深拷贝
	~AVLTree()
	{

	}
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}
		Node* parent = nullptr, * cur = _root;
		//找到存储的位置
		while (cur)
		{
			if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}


		}
		cur = new Node(kv);
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;

		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;

		}
	
		//控制平衡
		//1.更新平衡因子 -- 新增节点到根节点的路径
		//2.出现一场平衡因子，需要旋转处理

		while (cur->_parent)
		{
			parent = cur ->_parent;
			if (cur == parent->_left)
			{
				parent->_buf--;
				
			}
			else if (cur == parent->_right)
			{
				parent->_buf++;
			}
			if (parent->_buf == 0)//如果parent的平衡因子等于0.则停止更新
			{
				break;
			}
			//如果parent的平衡因子等于1或者 - 1.则继续往上更新  （说明parent所在的子树高度加1）
			else if (parent->_buf == 1 || parent->_buf == -1)	
			{
				cur = cur->_parent;
			}
			//如果parent的平衡因子等于2或者 - 2.已经出现不平衡现象，需要旋转处理
			else if (parent->_buf == 2 || parent->_buf == -2)
			{
				//说明parent所在的子树已经不平衡，需要旋转处理
				if (parent->_buf == -2)
				{
					if (cur->_buf == -1)
					{
						//左边高，右单旋
						RotateR(parent);
					}
					else if(parent->_buf == -2 && cur->_buf == 1)
					{
						RotateLR(parent);
					}
					
				}
				else //parent->_buf == 2
				{
					if (cur->_buf == 1)
					{
						//右边高，左单旋
						RotateL(parent);
					}
					else if(parent->_buf == 2 && cur->_buf == -1)
					{
						RotateRL(parent);
					}
				}
				break;
			}
			else	//说明在插入结点之前，树已经不平衡了，或者是bf出错，需要检查其他逻辑错误
			{
				assert(false);
			}
		}
		return true;
	}
	void RotateLR(Node* parent)//左右双旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_buf;
		RotateL(parent->_left);
		RotateR(parent);
		//..._buf的重置问题
		if (bf == 0)
		{
			parent->_buf = 0;
			subL->_buf = 0;
			subLR->_buf = 0;
		}
		else if (bf == -1)
		{
			parent->_buf = 1;
			subL->_buf = 0;
			subLR->_buf = 0;
		}
		else if (bf == 1)
		{
			parent->_buf = 0;
			subL->_buf = -1;
			subLR->_buf = 0;
		}
		else
		{
			assert(false);
		}
	}
	void RotateRL(Node* parent)//右左双旋
	{
		//根据subRL节点的平衡因子_buf来识别三种情况。
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		int bf = subRL->_buf;
		RotateR(parent->_right);
		RotateL(parent);
		//..._buf的重置问题
		if (bf == 0)
		{
			parent->_buf = 0;
			subR->_buf = 0;
			subRL->_buf = 0;
		}
		else if (bf == -1)
		{
			parent->_buf = 0;
			subR->_buf = 1;
			subRL->_buf = 0;
		}
		else if (bf == 1)
		{
			parent->_buf = -1;
			subR->_buf = 0;
			subRL->_buf = 0;
		}
		else
		{
			assert(false);
		}
	}
	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* parentParent = parent->_parent;
		parent->_left = subLR;

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

			subL->_parent = parentParent;
		}
		subL->_buf = parent->_buf = 0;
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* parentParent = parent->_parent;
		parent->_right = subRL;

		if (subRL)
		{
			subRL->_parent = parent;
		}
		subR->_left = parent;
		parent->_parent = subR;
		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
				parentParent->_left = subR;
			else
				parentParent->_right = subR;

			subR->_parent = parentParent;
		}
		subR->_buf = parent->_buf = 0;
	}
	int Height(Node* root)
	{
		if (root == nullptr)
			return 0;
		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);
			return (leftHeight > rightHeight) ? (leftHeight + 1) : (rightHeight + 1) ;
	}
	bool _IsBlance(Node* root)
	{
		if (root == nullptr)
			return true;

		int leftHeight = Height(root->_left);
		int rightHeight = Height(root->_right);

		return abs(leftHeight - rightHeight) < 2
			&& _IsBlance(root->_left)
			&& _IsBlance(root->_right);
	}
	bool IsBlance()
	{
		return	_IsBlance(_root);
	}
	void _Inorder(const Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout << (root->_kv).first << ": " << (root->_kv).second << endl;
		_Inorder(root->_right);
	}
	void Inorder()
	{
		_Inorder(_root);
	}
	Node* Find(const K& key)
	{
		return nullptr;
	}
	bool Erase(const K& key)
	{
		return false;
	}
private:
	Node* _root;
};

2.红黑树的简单实现

#pragma once
#pragma once
enum Colour {
	RED,
	BLACK
};
template <class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _data;
	
	Colour _colour;

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

template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBTreeNode<T>  Node;
	typedef RBTreeIterator<T, Ref, Ptr> Self;
	
	Node* _node;
	
	RBTreeIterator(Node* node)
		:_node(node)
	{}
	Ref operator*()
	{
		return _node->_data;
	}
	Ptr operator->()
	{
		return &(_node->_data);
	}

	Self& operator++()
	{
		if (_node->_right)
		{
			Node* min = _node->_right;
			while (min->_left)
			{
				min = min->_left;
			}
			_node = min;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_right)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	Self& operator--()
	{
		if (_node->_left)
		{
			Node* min = _node->_left;
			while (min->_right)
			{
				min = min->_right;
			}
			_node = min;
		}
		else
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && cur == parent->_left)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}
		return *this;
	}

	bool operator!=(const Self& s)const
	{
		return _node != s._node;
	}
	bool operator==(const Self& s)const
	{
		return _node == s._node;
	}
};

//set RBTree<K,K>
//map RBTree pair<K, V>
template<class K, class T, class KeyOfT>
struct RBTree
{
	typedef RBTreeNode<T>  Node;
public:
	typedef RBTreeIterator<T, T&, T*> iterator;
	typedef RBTreeIterator<T, const T&, const T*> const_iterator;

	iterator begin()
	{
		Node* min = _root;
		while (min && min->_left)
		{
			min = min->_left;
		}
		return iterator(min);
	}
	iterator end()
	{
		return iterator(nullptr);
	}
	RBTree()
		:_root(nullptr)
	{}

	RBTree(const RBTree<K, T, KeyOfT>& t)
	{
		_root = Copy(t._root);
	}
	
	RBTree<K, T, KeyOfT>& operator=(RBTree<K, T, KeyOfT> t)
	{
		swap(_root, t._root);
		return *this;
	}

	iterator Find(const K& key)
	{
		Node* cur = _root;
		KeyOfT kot;
		while (cur)
		{
			if (kot(cur->_data) < key)
			{
				cur = cur->_right;
			}
			else if(kot(cur->_data) > key)
			{
				cur = cur->_left;
			}
			else
			{
				return iterator(cur);
			}
		}
		return end();
	}


	pair<iterator, bool> Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_colour = BLACK;
			return make_pair(iterator(_root), true);
		}


		KeyOfT kot;


		Node* parent = nullptr, * cur = _root;
		//找到存储的位置
		while (cur)
		{
			if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return make_pair(iterator(cur), false);
			}
		}
		cur = new Node(data);
		Node* newnode = cur;
		cur->_colour = RED;//新增节点
		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
			cur->_parent = parent;

		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;

		}


		//控制平衡
		while (parent && parent->_colour == RED)
		{
			//一定有祖父
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//1. uncle存在且为红
				if (uncle && uncle->_colour == RED)
				{
					//变色+继续向上处理
					parent->_colour = uncle->_colour = BLACK;
					grandfather->_colour = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else//2.uncle不存在/存在且为黑
				{
					//         g
					//		p
					//	cur
					//右单旋
					if (cur == parent->_left)
					{
						RotateR(grandfather);
						parent->_colour = BLACK;
						grandfather->_colour = RED;
					}
					//         g
					//		p
					//		   cur
					//左右双旋
					else
					{
						RotateL(parent);
						RotateR(grandfather);
						cur->_colour = BLACK;
						grandfather->_colour = RED;
					}
					break;
				}
			}

			else
			{
				Node* uncle = grandfather->_left;
				//1. uncle存在且为红
				if (uncle && uncle->_colour == RED)
				{
					//变色+继续向上处理
					parent->_colour = uncle->_colour = BLACK;
					grandfather->_colour = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else//2.uncle不存在/存在且为黑
				{
					//         g
					//				p
					//					cur
					//左单旋
					if (cur == parent->_right)
					{
						RotateL(grandfather);
						parent->_colour = BLACK;
						grandfather->_colour = RED;
					}
					//         g
					//				p
					//		   cur		
					//右左双旋
					else
					{
						RotateR(parent);
						RotateL(grandfather);
						cur->_colour = BLACK;
						grandfather->_colour = RED;
					}
					break;
				}
			}
		}
		_root->_colour = BLACK;
		return make_pair(iterator(newnode), true);
	}
	bool _IsBalance(Node* root, int banchmark, int blackNum)
	{
		if (root == nullptr)
		{
			return (banchmark == blackNum);
		}
		if ((root->_colour == RED) && (root->_parent->_colour == RED))
		{
			cout << "出现连续红节点" << endl;
			return false;
		}
		if (root->_colour == BLACK)
			blackNum++;
		return _IsBalance(root->_left, banchmark, blackNum)
			&& _IsBalance(root->_right, banchmark, blackNum);

	}

	~RBTree()
	{
		Destory(_root);
		_root = nullptr;
	}
private:

	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* parentParent = parent->_parent;
		parent->_left = subLR;

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

			subL->_parent = parentParent;
		}
		
	}
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		Node* parentParent = parent->_parent;
		parent->_right = subRL;

		if (subRL)
		{
			subRL->_parent = parent;
		}
		subR->_left = parent;
		parent->_parent = subR;
		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
				parentParent->_left = subR;
			else
				parentParent->_right = subR;

			subR->_parent = parentParent;
		}
	}
	
	void Destory(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		Destory(root->_left);
		Destory(root->_right);
		delete root;
	}
	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;
		Node* newRoot = new Node(root->_data);
		//newRoot->
		newRoot->_colour = root->_colour;
		newRoot->_left = Copy(root->_left);
		newRoot->_right = Copy(root->_right);
		if (newRoot->_left)
			newRoot->_left->_parent = newRoot;
		
		if (newRoot->_right)
			newRoot->_right->_parent = newRoot;
		
		return newRoot;
	}
	

private:
	Node* _root;
};

3.使用红黑树简单实现set

#pragma once
#include"RBTree.h"

namespace yqx
{
	template<class K>
	class set
	{
	public:
		struct SetKeyOfT
		{
			const K& operator()(const K& k)
			{
				return k;
			}
		};
		typedef typename RBTree<K, K, SetKeyOfT>::iterator iterator;

		iterator begin()
		{
			return _t.begin();
		}
		iterator end()
		{
			return _t.end();
		}
		
		pair<iterator, bool> insert(const K& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};

	void test_set()
	{
		set<int> s;
		s.insert(1);
		s.insert(2);
		s.insert(3);
		s.insert(4);
		s.insert(5);
		s.insert(6);

		set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
		cout << "set：" << endl;
		for (auto e : s)
		{
			cout << e << " ";
		}
		cout << endl;
		set<int> copy(s);
		cout << "set拷贝copy：" << endl;
		for (auto e : copy)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

4.使用红黑树简单实现map

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

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

		
	};
	void test_map()
	{
		map<int, int> m;
		m.insert(make_pair(3, 3));
		m.insert(make_pair(1, 3));
		m.insert(make_pair(4, 5));
		m.insert(make_pair(6, 8));
		m.insert(make_pair(3, 10));
		m.insert(make_pair(4, 6));
		map<string, string> dict;
		dict.insert(make_pair("sort", "排序"));
		dict.insert(make_pair("apple", "苹果"));
		dict.insert(make_pair("map", "地图"));
		dict["left"];
		dict["left"] = "左边";
		dict["map"] = "地图,映射";
		auto it = dict.begin();
		cout << "map：" << endl;
		while (it != dict.end())
		{
			cout << it->first << ": " << it->second << endl;
			++it;
		}
		cout << endl;
		map<string, string> copy_map(dict);
		cout << "copy_map：" << endl;
		for (auto e : copy_map)
		{
			cout << e.first << ": " << e.second << endl;
		}
		cout << endl;
	}
}
倚心
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 2735
红黑树详解
使用红黑树封装map和set
qq_47406941的博客
06-07 772
红黑树和AVL树都是二叉搜索树，但是从效率以及实现方式等方面综合来看，红黑树比AVL树更优。也就是说，红黑树是一种更好的，适合搜索的数据结构。同时，红黑树的使用方面非常广泛，Java库、linux内核、c++ST ...
【C++】红黑树封装实现map和set
The porters of knowledge
04-01 1002
用一棵红黑树封装map和set，set表层迭代器底层均为红黑树的const迭代器，实现map的[ ]重载……
C++红黑树模拟实现map和set
~
04-01 3901
C++红黑树模拟实现map和set零、前言一、红黑树及其节点的设计1、树节点的设计2、红黑树的设计3、取值仿函数的使用二、红黑树的迭代器1、begin()与end()2、operator++()与operator--()3、正反迭代器的实现三、map和set的实现1、红黑树的实现2、map的封装3、set的封装 零、前言 本章是继红黑树的介绍和实现后，讲解使用红黑树来封装实现map和set 一、红黑树及其节点的设计 对于底层都是红黑树的map和set来说，他们之间存在的最大的区别就是：对于set是K模
【map、set】C++用红黑树来封装map、set容器
m0_68617301的博客
05-23 842
我们在模拟红黑树的时候一律用了`pair`的`KV`模型来进行实现。但是由于`map`是`KV`模型的而`set`是`K`型的，但是底层都是用的红黑树，那么应该如何进行调整呢？
C++STL学习笔记 红黑树、容器set、multiset、map、multimap
平凡
04-07 556
一、红黑树（RB-Tree）---map，set，multimap,multiset底层使用红黑树 Red-Black tree(红黑树)是平衡二分搜索树（balanced binary search tree）中常被使用的一种。平衡二分搜索树的特性：排列规则有利search和insert，并保持适度平衡---无任何结点过深。 RB-Tree提供遍历操作及iterators。 按正常规则（++ite）遍历，便能获得排序状态（sorted）。 我们不应该使用RB-Tree的iterators改变元素值
C++红黑树封装set和map（很详细）
kkbca的博客
12-06 999
set和map的底层就是红黑树，现在我们要用这一棵树来封装STL里面的容器：set和map。
AVL树和红黑树（map和set的底层实现）
海盗船长y的博客
04-26 1233
map和set的概念及使用 map和set的底层结构 map和set其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。 AVL树 AVL树的概念 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉...
【C++】红黑树 --- map/set 底层
YoungMLet的博客
11-13 1213
了解 map/set 底层红黑树的插入！使用红黑树封装 map/set ！
红黑树的实现、map、set的封装
ych9527的博客
06-02 426
1.红黑树概念、性质 1.1什么是红黑树 红黑树，是一种二叉搜索树，但是在每个节点上增加了一个存储位，标识节点的颜色，可以是RED或者BLACK。通过对任何一条从根到叶子的路径上各个节点着色方式的限制，红黑树确保没有一条路径会比其它的路径长出两倍(最长路径<=2倍最短路径)，因此是接近平衡的 1.2红黑树的性质 1.每个节点不是红色就是黑色的 2.根节点是黑色的 3.没有连续的两个红色节点 4.对于每个节点，从该节点到其后代叶节点的路径上，均包含相同的黑色节点(每条路径上的黑色节点的总数是相同的) 5
c++关联容器用法详解（set与map）
01-27
1. map和set的插入和删除效率较高，是因为它们内部采用红黑树实现，插入和删除仅涉及节点的调整，不涉及元素的内存拷贝和移动。 2. insert操作后，已存在的iterator不会立即失效，因为元素内存未改变，iterator仍然...
使用C++实现的rbtree红黑树.zip
03-21
红黑树（Red-Black Tree）是一种自平衡的二叉...红黑树广泛应用于各种数据结构和算法中，如STL中的map和set容器，以及数据库索引等场景。理解和掌握红黑树的原理及C++实现，对于提升编程能力和解决实际问题大有裨益。
c++容器list、vector、map、set区别与用法详解
12-17
c++容器list、vector、map、set区别 list 封装链表，以链表形式实现，不支持[]运算符。 对随机访问的速度很慢(需要遍历整个链表)，插入数据很快(不需要拷贝和移动数据，只需改变指针的指向)。 新添加的元素，...
红黑树实现源码
07-22
红黑树因其高效性能在许多实际应用中得到采用，如C++标准模板库(STL)中的set和map容器，以及Java的TreeMap和TreeSet类。它们使用红黑树作为底层数据结构，提供快速的查找、插入和删除操作。 5. 红黑树的优势： - ...
【18】输出字符菱形
2301_78786609的博客
07-19 365
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
2024.7.19 刷题总结
最新发布
TheJustice_的博客
07-19 221
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
(算法)区间调度问题
2202_75519246的博客
07-17 238
此外,参与工作的时间段不能重复(即使是开始的瞬间和结束的瞬间的重叠也是不允许的). 你的目标是参与尽王多的工作,那么最多能参与多少项工作呢?有n项工作,每项工作分别在s时间开始,在t时间结束. 对于每项工作,你都可以选择参与与否,如果选择了参与,那么自始至终都必须全程参与.
傻瓜图解 -- 算法刷题之路之链表初探（八 ）旋转链表
aoyuanyuan0921的博客
07-19 170
今天来学习的算法题是leecode61旋转链表，是一道简单的入门题，话不多说！原子本来写了一大推书面解释！我直接上图，如果有疑问的话私信我交流一下！
【刷题汇总 -- 压缩字符串(一)、chika和蜜柑、 01背包】
m0_69455439的博客
07-19 1124
今日刷题汇总day018 -- 压缩字符串(一)、chika和蜜柑、 01背包
C++ map set 红黑树
07-28
基于红黑树实现的map容器是一种有序的关联容器，它存储键值对，并根据键的顺序进行排序。每个键值对在map中唯一，且按照键进行升序排列。 基于红黑树实现的set容器是一种有序的集合容器，它存储唯一的元素，并按照...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

倚心

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

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

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

打赏作者

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

抵扣说明：

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

余额充值