_cpp利用红黑树封装实现map和set

已于 2022-11-29 18:28:08 修改
阅读量796 收藏 1
点赞数 2
分类专栏： c++ 数据结构与算法 文章标签： 前端 数据结构
于 2022-11-06 18:31:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dingyuan0/article/details/127718509
版权

文章目录

0. 前言

链接：_cpp 红黑树快速了解底层结构
上面那篇文章，我们了解了红黑树的底层结构并模拟实现红黑树数据插入；最后我们又验证我们红黑树的准确性。

这篇文章我们利用红黑树封装实现map和set。

1. 改造红黑树

1.1 红黑树节点的定义

  • 因为我们要利用一颗树封装实现map和set，所以我们不能写死。

  • 怎么作那看下面代码。

enum Colour
{
	RED,
	BLACK
};

template<class T>	//k or pair<K, V>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;

	//pair<K, V> _kv;
	T _date;	//   数据
	Colour _col;

	RBTreeNode(const T& date)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _date(date)
	{}
};

  • 我们把模板template<class K, class V>改为template; 而T代表k or pair<K, V>。这样就实现了泛型。

  • 看到这里uu们就很疑惑，那怎么区别那？我们就要借助仿函数（KeyOfT ）-> 支持取出T对象中key的值。

1.2 红黑树中的迭代器

  • 迭代器大致框架跟list模拟实现不变，变的是++和- -怎么操作。我们知道红黑树的中序遍历可以得到一个有序序列；而我们的加加和减减就是查找中序遍历中某一个节点前后的节点是那个。

1.2.1 模拟实现前置加加的方法

在这里插入图片描述

  • 通过上图和根据中序遍历的规则，我们很快就发现两条规律。

    1. 右子树不为空，++就是找右子树中序第一个(最左节点)；

      • 例如：11的下一个节点就是12，根据中序遍历的规则。

    2. 右子树为空，++找孩子不是父亲右的那个祖先。

      • 例如：12的下一个节点就是13，根据中序遍历的规则；而7的下一个节点是8，不是6。

在这里插入图片描述

1.2.2 模拟实现前置减减的方法

在这里插入图片描述

  • 通过上图和根据中序遍历的规则，我们很快就发现两条规律。

    1. 左子树不为空，–就是找右子树中序最后一个(最右节点)；

      • 例如：8的上一个节点就是7，根据中序遍历的规则。

    2. 左子树为空，–找孩子不是父亲左的那个祖先。

      • 例如：15的上一个节点就是13，根据中序遍历的规则；而12的上一个节点是11，而不是13。

到了这里我们发现–和++恰好相反；后置++与- -我们复用一下前置的就可以实现了。

1.2.3 红黑树迭代器代码

template<class T, class Ref, class Ptr>		//T T& T*
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef  __RBTreeIterator<T, Ref, Ptr> Self;

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

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

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


	Self& operator++()
	{
		//思路：左子树的父亲，右子树的父亲的父亲直到找到另一个子树的左节点（模拟中序遍历）

		if (_node->_right)//右子树不为空，下个就是右子树最左节点
		{
			// 下一个就是右子树的最左节点
			Node* left = _node->_right;
			while (left && left->_left)
			{
				left = left->_left;
			}

			_node = left;
		}
		else         // 找祖先里面孩子不是祖先的右的那个
		{
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent && cur == parent->_right)
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}
			
			_node = parent;
		}

		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		++(*this);

		return tmp;
	}

	Self& operator--()
	{
		if (_node->_left)
		{
			Node* right = _node->_right;
			while (right && right->_right)
			{
				right = right->_right;
			}

			_node = right;
		}
		else
		{
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent && cur == parent->_left)
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}

			_node = parent;
		}

		return *this;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		--(*this);

		return tmp;
	}

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

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

private:
	Node* _node;

};

1.3 仿函数

  • 因为map是pair<K,V>; kv型原来的直接比较并插入就失效了，我们就需要借助仿函数来提取map中pair的first值；来进行比较。

	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};

	template<class k>
	class set
	{
		struct SetKeyOfT
		{
			const k& operator()(const k& key) 
			{
				return key;
			}
		};

实现过程就在上图代码里了。

1.4 红黑树整体改造完成后的代码

#pragma once
#include<iostream>
#include<assert.h>

using namespace std;
enum Colour
{
	RED,
	BLACK
};

template<class T>	//k or pair<K, V>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;

	//pair<K, V> _kv;
	T _date;	//   数据
	Colour _col;

	RBTreeNode(const T& date)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _date(date)
	{}
};

template<class T, class Ref, class Ptr>		//T T& T*
struct __RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef  __RBTreeIterator<T, Ref, Ptr> Self;

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

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

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


	Self& operator++()
	{
		//思路：左子树的父亲，右子树的父亲的父亲直到找到另一个子树的左节点（模拟中序遍历）

		if (_node->_right)//右子树不为空，下个就是右子树最左节点
		{
			// 下一个就是右子树的最左节点
			Node* left = _node->_right;
			while (left && left->_left)
			{
				left = left->_left;
			}

			_node = left;
		}
		else         // 找祖先里面孩子不是祖先的右的那个
		{
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent && cur == parent->_right)
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}
			
			_node = parent;
		}

		return *this;
	}
	Self operator++(int)
	{
		Self tmp(*this);
		++(*this);

		return tmp;
	}

	Self& operator--()
	{
		if (_node->_left)
		{
			Node* right = _node->_right;
			while (right && right->_right)
			{
				right = right->_right;
			}

			_node = right;
		}
		else
		{
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent && cur == parent->_left)
			{
				parent = parent->_parent;
				cur = cur->_parent;
			}

			_node = parent;
		}

		return *this;
	}
	Self operator--(int)
	{
		Self tmp(*this);
		--(*this);

		return tmp;
	}

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

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

private:
	Node* _node;

};

// T决定红黑树存什么数据
// set  RBTree<K, K>
// map  RBTree<K, pair<K, V>>
// KeyOfT -> 支持取出T对象中key的仿函数
template<class K, class T, class keyOfT>
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef __RBTreeIterator<T, T&, T*> iterator;
	iterator begin()
	{
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}
		//找到最左，也就是最小值

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


	RBTree()
	{}

	pair<iterator, bool> Insert(const T& date)
	{

		keyOfT kot;
		if (_root == nullptr)
		{
			_root = new Node(date);
			_root->_col = BLACK;
			return make_pair(iterator(_root), true);
		}

		//找find
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_date) < kot(date))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_date) > kot(date))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				//重复的
				return make_pair(iterator(cur), false);
			}
		}


		//插入
		cur = new Node(date);
		Node* newNode = cur;	//记录一下，最后返回的时候要用。
		cur->_col = RED;

		if (kot(parent->_date) < kot(date))
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		//调整颜色
		while (parent && parent->_col == RED)	//父母为红，违法规则；才调整
		{
			Node* grandfather = parent->_parent;
			assert(grandfather);
			assert(grandfather->_col == BLACK);
			//关键看叔叔
			//     g
			//   p or p
			// 
			if (parent == grandfather->_left)
			{
				Node* uncle = grandfather->_right;
				//情况一: uncle存在且为红，变色＋继续往上调整
				//     g
				//   p   u
				//   c
				if (uncle && uncle->_col==RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else  //uncle || uncle->_col == BLACK
				{
					//情况二、三: uncle存在且为黑或者不存在，变色＋旋转
					if (cur == parent->_left)
					{
						//     g				p
						//   p   u			  c	  g
						//  c						u
						//(g)右单旋＋变色
						RotateR(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//     g             g				c
						//   p   u		   c   u		  p	   g
						//		c		 p	                     u
						//(p)左单旋＋(g)右单旋+ 变色
						RotateL(parent);
						RotateR(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
			else    //parent == grandfather->_right
			{
				Node* uncle = grandfather->_left;

				if (uncle && uncle->_col == RED)
				{
					parent->_col = BLACK;
					uncle->_col = BLACK;
					grandfather->_col = RED;

					cur = grandfather;
					parent = cur->_parent;
				}
				else  //uncle || uncle->_col == BLACK
				{
					//情况二、三: uncle存在且为黑或者不存在，变色＋旋转
					if (cur == parent->_right)
					{
						//(g)左单旋＋变色
						RotateL(grandfather);
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//(p)右单旋＋(g)左单旋+ 变色
						RotateR(parent);
						RotateL(grandfather);
						cur->_col = BLACK;
						grandfather->_col = RED;
					}

					break;
				}
			}
		}

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

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()
	{
		if (_root == nullptr)
		{
			return true;
		}

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

		//黑色节点数量的基准
		int benchmark = 0;

		return PrecCheck(_root, 0, benchmark);
	}
private:
	bool PrecCheck(Node* root, int blackNum, int& benchmark)
	{
		if (root == nullptr)
		{
			if (benchmark == 0)
			{
				benchmark = blackNum;
				return true;
			}

			if (benchmark != blackNum)
			{
				cout << "某条黑色结点数量不对" << endl;
				return false;
			}
			else
			{
				return true;
			}
		}

		if (root->_col == BLACK)
		{
			++blackNum;
		}

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "存在连续的红节点" << endl;
			return false;
		}

		return  PrecCheck(root->_left, blackNum, benchmark)
			&& PrecCheck(root->_right, blackNum, benchmark);
	}

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

		_InOrder(root->_left);
		cout << kot(root->_date) << " ";
		_InOrder(root->_right);
	}

	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 (_root == parent)
		{
			_root = subL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}

	}

	void RotateL(Node* parent)	//左旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
		{
			subRL->_parent = parent;
		}

		Node* ppNode = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;
		if (parent == _root)
		{
			_root = subR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else  //ppNode->_right == parent
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}

	}

	Node* _root = nullptr;
};

2. 封装实现map

  • 注意：typename的使用–我们要取取类里面的类型而不是变量（例如：类的静态变量）需要说明。
#pragma once
#include "BR_TREE.h"

namespace Ding
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		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);
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert(make_pair(key, V()));

			return ret.first->second;
		}

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

3. 封装实现set

  • 注意：typename的使用–我们要取取类里面的类型而不是变量（例如：类的静态变量）需要说明。
#pragma once
#include "BR_TREE.h"

namespace Ding
{
	template<class k>
	class set
	{
		struct SetKeyOfT
		{
			const k& operator()(const k& key) 
			{
				return key;
			}
		};

	public:
		typedef typename RBTree<k, k, SetKeyOfT>::iterator iterator;	//typedef--告诉编译器我们这里取得是类里面的类型而不是变量

		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;
	};
}

4. 测试案例

/map.h///

	void test_set()
	{
		set<int> s;

		set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		s.insert(3);
		s.insert(2);
		s.insert(1);
		s.insert(5);
		s.insert(3);
		s.insert(6);
		s.insert(4);
		s.insert(9);
		s.insert(7);


		it = s.begin();
		while (it != s.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}

/set.h///

	void test_map()
	{
		string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };

		map<string, int> countMap;
		for (auto& str : arr)
		{
			// 1、str不在countMap中，插入pair(str, int()),然后在对返回次数++
			// 2、str在countMap中，返回value(次数)的引用，次数++;
			countMap[str]++;
		}

		map<string, int>::iterator it = countMap.begin();
		while (it != countMap.end())
		{
			cout << it->first << ":" << it->second << endl;
			++it;
		}

		for (auto& kv : countMap)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
	}

5. 测试结果

在这里插入图片描述

昨天；明天。今天。
关注
专栏目录
Cpp || 模拟实现map
Template Code
04-22 325
文章目录map底层(RBTree.hpp)红黑树用于封装底层红黑树的Map_RBTree.hpp用于测试模拟实现map的代码 map底层(RBTree.hpp)红黑树 #pragma once #include<iostream> #include<functional> using namespace std; enum Color{ Red, Black ...
关于红黑树的迭代器原理及实现
liuming
11-11 523
首先介绍什么是迭代器： 迭代器是一种设计模式，设计一种结构依次序去遍历容器中的数据，而又无需暴露容器的底层设计细节，在我看来，迭代器的出现最重要的目的就是为了简单方便；同一种方式可以遍历不同的容器，不管底层结构是是顺序表，链表还是树。虽然使用方式相同，但是不同的容器中迭代器的实现方式是不同的，本文介绍红黑树的迭代器的实现方式。 迭代器的本质： 本质上是指针或者对指针的封装。 如何设计容器中的迭代器： 首先要明白容器的底层数据结构，按照什么规则进行遍历，其实使用一个类进行迭...
map、list,红黑树
adn34322的博客
07-17 204
map、list,红黑树 转载于:https://www.cnblogs.com/jerrice/p/7194028.html
cpp-sparsemap一个高效hashmap和hashset的C实现
08-16
sparse-map一个高效hash map和hash set的C 实现
C/Cpp / STL / map 和 set 的不同点和相同点。
布袋和尚
02-27 499
1、节点类型 （1）map，节点保存的内容是 key 和 value 。 （2）set，节点保存的是 key。当然，理解成 value 亦可。这里说 key，是因为代码中写的是 key 。 2、其他 （1）set，集合。包含了经过排序了的数据，这些数据的值 （value）必须是唯一的（因为红黑树需要按照 value 进行判断大小）。 （2）map，映射，即：从 key 到 value 的映...
alogrithm_structure_cpp
02-14
`std::set`和`std::map`是基于红黑树实现的关联容器，提供了键值对的存储和快速查找。 2. **迭代器**：迭代器是访问容器内元素的一种机制，类似于指针，但具有更丰富的操作和安全特性。通过迭代器，可以遍历容器的...
c++stl中红黑树的实现
最新发布
09-14
在C++ STL中，红黑树的实现被封装在`std::map`和`std::set`这两个容器类中。这两个容器类都是基于红黑树实现的，它们提供了高效的查找、插入和删除操作，保证了元素的有序性。 STL中的红黑树实现与你提供的C++代码...
cpp:C ++语言概念的详细信息以及使用C ++的算法和数据结构的实现
03-10
本篇文章将深入探讨C++语言的核心概念，包括其语法、特性，以及如何利用C++来实现算法和数据结构，并提到了在实际编码平台上的应用。 1. **C++语言概念** - **类与对象**：C++中的核心概念是类，它是创建对象的...
-cpp-stl:容器基本实现
04-13
`std::set`是红黑树（Red-Black Tree）的实现，它存储唯一的元素，并保持排序。插入和查找操作的时间复杂度为O(log n)。 6. **映射（map）** `std::map`也是基于红黑树的，它存储键值对，其中键是唯一的。通过键...
Cpp浅析系列-STL之map
君匡的博客
08-28 2766
`map` 是**有序**的键值对容器，元素的**键是唯一的，值允许重复**。用比较函数 `Compare` 排序键。搜索、移除和插入操作拥有对数复杂度，即`O(logn)`。 底层实现为红黑树。
C++ 第九节——map/set(用法+底层原理+模拟实现)
jxwd的博客
03-05 7320
有了前面红黑树的底子，我们这一节的任务就比较轻松了。 关于Map和Set是什么东西，我们来借助网络文献进行解释。 首先，我们需要知道的是，Map和Set的底层都是红黑树。 即是一种平衡的二叉搜索树，也就是二叉平衡搜索树。 而set就是我们前面说到的Key模型，而map就是<K,V>模型。 我们接下来将一边对比，一边介绍。 set和map的介绍 先来看set: 通过查阅文档有关set的声明，我们可以发现： 这里的T就是我们所说的Key，就是key_type或者说是value_
C++ map的简单实现
WhiteShirtI的博客
05-23 5776
map和set的底层都是通过红黑树来实现的，但并不是原生态的红黑树，而是经过改造后的红黑树。且容器都会在各自的类中添加一些独特的函数来解决各自适配的问题 map和set底层是改造后的红黑树，我们先来看看改造后的红黑树 和普通的红黑树不同的是，在根节点上再加了一个头结点，该结点不是真实的结点，只是一个辅助结点，是为了后面实现红黑树的迭代器而出现的。该header结点的父节点就是真实的根节点，其左孩子是这棵树的最左结点，其右孩子是这棵树的最右节点。 我们现在通过STL源码来简单剖析一下map和set中如何利用
C++ 中各种map的使用
热门推荐
雨石
12-14 1万+
C＋＋中有很多中key-value形式的容器，map／hash_map／unordered_map／vector_map。下面讲述各个map的使用及其区别。 首先，map的基本使用方法如下： #include #include using namespace std; typedef std::map Map; typedef Map::iterator MapIt; int ma
万门cpp课程作业:std的map实现原理
dlvector的博客
01-10 879
先上一张侯捷老师的图 map基本就是对红黑树的重新包装 我们看代码： map 的结构体定义： template <class _Key, class _Tp, class _Compare, class _Alloc> class map { public: typedef _Key key_type; // 键值类型 typedef...
CPP容器-map
ivalue的博客
09-18 6695
map是STL的一种关联式容器，他提供一对一的Hash映射，因此使用中也常常可pair数据结构结合使用，map内部自建一棵红黑树，这棵树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的，也基于此，不能直接改变元素的key，因为这会破坏正确次序，要修改元素的key，必须先移除该key的元素，然后插入拥有新的key/value的元素；任何两个元素没有相同的key值 https://bl...
c++中map的基本用法和嵌套用法
CPP工程师的专栏
10-17 1万+
C++中map容器提供一个键值对容器，map与multimap差别仅仅在于multiple允许一个键对应多个值。本文主要总结一下map基本用法和嵌套用法示例。 一、map基本用法   1   头文件    #include       2   定义    map   my_Map; //注意这里的int和int可以是其他类型   或者是typedef     map
带你深入理解STL之Set和Map
ZeeCoder
09-09 1万+
在上一篇博客中，讲到了STL中关于红黑树的实现，理解起来比较复杂，正所谓前人种树，后人乘凉，RBTree把树都种好了，接下来就该set和map这类关联式容器来“乘凉”了。STL的set和map都是基于红黑树实现的，和stack和queue都是基于deque一样，它们仅仅是调用了RBTree提供的接口函数，然后进行外层封装即可。本篇博客理解起来比较轻松，set和map的源代码也不多，大家可以慢慢“品味
stl 容器比较
abcd1f2的专栏
06-26 998
List封装了链表,Vector封装了数组, list和vector得最主要的区别在于vector使用连续内存存储的，他支持[]运算符，而list是以链表形式实现的，不支持[]。 Vector对于随机访问的速度很快，但是对于插入尤其是在头部插入元素速度很慢，在尾部插入速度很快。List对于随机访问速度慢得多，因为可能要遍历整个链表才能做到，但是对于插入就快的多了，不需要拷贝和移动数据，只需要改变
C++红黑树实现Map
07-28
当然，我可以帮你实现一个基于红黑树的Map数据结构。下面是一个简单的C++代码示例： ```cpp #include enum Color { RED, BLACK }; template , typename V> struct Node { K key; V value; Color color; Node...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

昨天；明天。今天。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值