map和set的封装细节

已于 2024-05-29 15:21:34 修改
阅读量287 收藏 7
点赞数 3
分类专栏： STL 文章标签： 数据结构
于 2024-05-22 10:24:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yonlylove/article/details/139038398
版权

目录

一，红黑树部分

1.模板参数​编辑

2.节点插入部分

3.验证树是否是红黑树

4.旋转实现

二，迭代器部分

1.前置加加的实现

2.保证set和map对应的Key不能被修改。

3.map方括号的实现

三，封装源码

一，红黑树部分

1.模板参数

K为find是通过K的类型去查找，T为红黑树中节点的类型，KeyOFT为比较插入时需要拿到T中的KEY参数。

如何实现KeyOFT仿函数 细节：

在MySet类中，我们知道此时的节点为单参数Key，所以直接返回值就可以。

在MyMap类中，我们知道此时的节点为一个pair，所以返回pair的第一个参数用作比较插入。

2.节点插入部分

细节：看代码注释

std::pair<Iterator,bool> insert(const T& t) {
			if (_root == nullptr) {
				_root = new Node(t);
				return std::make_pair(_root,true);
			}
			KeyOFT kot;
			Node* parent = _root;
			Node* cur = _root;
			while (cur) {
				if (kot(cur->_data) > kot(t)) {
					parent = cur;
					cur = cur->_left;
				}
				else if (kot(cur->_data) < kot(t)) {
					parent = cur;
					cur = cur->_right;
				}
				else {
					return std::make_pair(cur, false);
				}
			}
			cur = new Node(t);
			Node* recur = cur;
			if (kot(t) < kot(parent->_data)) {
				parent->_left = cur;
				cur->_parent = parent;
			}
			else if (kot(t) > kot(parent->_data)) {
				parent->_right = cur;
				cur->_parent = parent;
			}
			else {
				return std::make_pair(cur, false);
			}
			while (parent && parent->_col == RED) {
				Node* grandFather = parent->_parent;
				if (grandFather == nullptr) {
					break;
				}
				if (grandFather&&parent == grandFather->_left) {
					//    g
					//  p   u
					Node* uncle = grandFather->_right;
					//叔叔存在且为红，只需向上变色即可
					if (uncle && uncle->_col == RED) {
						parent->_col = BLACK;
						uncle->_col = BLACK;
						grandFather->_col = RED;
						//继续向上处理
						cur = grandFather;
						parent = grandFather->_parent;
					}
					//叔叔不存在或者为黑，需要旋转，不需要再向上处理
					else {
						if (cur == parent->_left) {
							//    g
							//  p   u
							//c
							RotateR(grandFather);
							parent->_col = BLACK;
							grandFather->_col = RED;
							break;
						}
						else if (cur == parent->_right){
							//    g
							//  p   u
							//   c
							RotateL(parent);
							RotateR(grandFather);
							cur->_col = BLACK;
							parent->_col = RED;
							grandFather->_col = RED;
							break;
						}
						else {
							assert(false);
						}
					}
				}
				else if (grandFather && parent == grandFather->_right) {
					//    g
					//  u   p
					Node* uncle = grandFather->_left;
					//叔叔存在且为红，只需向上变色即可
					if (uncle && uncle->_col == RED) {
						parent->_col = BLACK;
						uncle->_col = BLACK;
						grandFather->_col = RED;
						//继续向上处理
						cur = grandFather;
						parent = grandFather->_parent;
					}
					//叔叔不存在或者为黑，需要旋转，不需要再向上处理
					else {
						if (cur == parent->_left) {
							//    g
							//  u   p
							//    c
							RotateR(parent);
							RotateL(grandFather);
							parent->_col = RED;
							grandFather->_col = RED;
							cur->_col = BLACK;
							break;
						}
						else if (cur == parent->_right) {
							//    g
							//  u   p
							//        c
							RotateL(grandFather);
							parent->_col = BLACK;
							grandFather->_col = RED;
							break;
						}
						else {
							assert(false);
						}
					}
				}
				else {
					assert(false);
				}
			}
            //保证根节点为黑
			_root->_col = BLACK;
			return std::make_pair(recur, true);
		}

3.验证树是否是红黑树

以接口的形式提供给外部，因为外部拿不到根节点。

细节：

先将一条路走到底，然后返回一共有多少黑节点，将此数据作为参考数据，然后遍历整棵树走到空的时候，对比参考数据，不相等则违反了每条路径的黑节点相等规则。

在遍历树的过程中，如果父节点和子节点都为红节点，则违反了红节点不相邻规则

4.旋转实现

细节图在往期中有画，这里附上源码

void RotateL(Node* parent) {
			Node* nodeR = parent->_right;
			Node* nodeRL = nodeR->_left;
			if (nodeRL) {
				nodeRL->_parent = parent;
			}
			Node* ppNode = parent->_parent;
			if (ppNode) {
				if (ppNode->_left == parent) {
					ppNode->_left = nodeR;
					nodeR->_parent = ppNode;
				}
				else {
					ppNode->_right = nodeR;
					nodeR->_parent = ppNode;
				}
			}
			else {
				_root = nodeR;
				nodeR->_parent = nullptr;
			}
			nodeR->_left = parent;
			parent->_right = nodeRL;
			parent->_parent = nodeR;
		}
		void RotateR(Node* parent) {
			Node* nodeL = parent->_left;
			Node* nodeLR = nodeL->_right;
			if (nodeLR) {
				nodeLR->_parent = parent;
			}
			Node* ppNode = parent->_parent;
			if (ppNode) {
				if (ppNode->_left == parent) {
					nodeL->_parent = ppNode;
					ppNode->_left = nodeL;
				}
				else {
					nodeL->_parent = ppNode;
					ppNode->_right = nodeL;
				}
			}
			else {
				_root = nodeL;
				nodeL->_parent = nullptr;
			}
			parent->_left = nodeLR;
			parent->_parent = nodeL;
			nodeL->_right = parent;
		}

二，迭代器部分

1.前置加加的实现

细节;

当此节点的右节点不为空时，找到右子树的最左节点，此时为当前节点的下一个节点

当右节点为空时，此时以此节点为根的整棵树都遍历完成，这是向上找到parent左边为cur的parent节点，此时parent为下一个需遍历节点。

注：减减逻辑与加加相反，这里不多加赘述，后置加加与减减直接复用前置的代码即可实现，封装源码部分有实现哦

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

2.保证set和map对应的Key不能被修改。

细节：封装时传入对应的节点参数使用const修饰

3.map方括号的实现

细节：

调用insert函数，insert返回一个pair，pair第一个参数为指向节点的迭代器，因为重载了-> ,所以迭代器调用second——首先调用->函数找到pair的地址，再去找到second，因为第二个参数可以修改，所以返回second的引用

三，封装源码

这里附上封装源码，分为四个文件进行封装

#pragma once
#include<assert.h>
#include<iostream>
namespace yuan {
	enum Colour {
		RED,
		BLACK
	};
	template<class T>
	struct RBNode {
		typedef RBNode<T> Node;
		Node* _left;
		Node* _right;
		Node* _parent;
		T _data;
		Colour _col ;
		RBNode(const T& data)
			:_left(nullptr)
			, _right(nullptr)
			, _parent(nullptr)
			, _data(data)
			, _col(RED)
		{}
	};
	template<class T,class Ref, class Ptr>
	struct IteratorRBtree {
		typedef IteratorRBtree<T,  Ref, Ptr> self;
		typedef RBNode<T> Node;
		Node* _node;
		IteratorRBtree(Node* node)
			:_node(node)
		{}
		Ptr operator->() {
			return &_node->_data;
		}
		Ref operator*() {
			return _node->_data;
		}
		bool operator!=(const self& s) {
			return _node != s._node;
		}
		self& operator++() {
			if (_node->_right) {
				Node* rightNode = _node->_right;
				Node* LeftMinNode = rightNode;
				while (LeftMinNode->_left) {
					LeftMinNode = LeftMinNode->_left;
				}
				_node = LeftMinNode;
			}
			else{
				Node* parent = _node->_parent;
				Node* cur = _node;
				while (parent && parent->_right == cur) {
					cur = parent;
					parent = parent->_parent;
				}
				_node = parent;
			}
			return *this;
		}
		self operator++(int) {
			self temp(this->_node);
			++(*this);
			return temp;
		}
	};
	template<class K,class T,class KeyOFT>
	class RBTree {
	public:
		typedef RBNode<T> Node;
		typedef IteratorRBtree<T, T&, T*> Iterator;
		typedef IteratorRBtree<T, const T&, const T*> const_Iterator;
		Iterator begin() {
			Node* cur = _root;
			while (cur->_left) {
				cur = cur->_left;
			}
			return cur;
		}
		Iterator end() {
			return nullptr;
		}
		const_Iterator end() const{
			return nullptr;
		}
		const_Iterator begin() const {
			Node* cur = _root;
			while (cur->_left) {
				cur = cur->_left;
			}
			return cur;
		}
		
		Iterator find(const K& t) {
			KeyOFT kot;
			Node* cur = _root;
			while (cur) {
				if (kot(cur->_data) > t) {
					cur = cur->_left;
				}
				else if (kot(cur->_data) < t) {
					cur = cur->_right;
				}
				else {
					return cur;
				}
			}
			return nullptr;
		}
		std::pair<Iterator,bool> insert(const T& t) {
			if (_root == nullptr) {
				_root = new Node(t);
				return std::make_pair(_root,true);
			}
			KeyOFT kot;
			Node* parent = _root;
			Node* cur = _root;
			while (cur) {
				if (kot(cur->_data) > kot(t)) {
					parent = cur;
					cur = cur->_left;
				}
				else if (kot(cur->_data) < kot(t)) {
					parent = cur;
					cur = cur->_right;
				}
				else {
					return std::make_pair(cur, false);
				}
			}
			cur = new Node(t);
			Node* recur = cur;
			if (kot(t) < kot(parent->_data)) {
				parent->_left = cur;
				cur->_parent = parent;
			}
			else if (kot(t) > kot(parent->_data)) {
				parent->_right = cur;
				cur->_parent = parent;
			}
			else {
				return std::make_pair(cur, false);
			}
			while (parent && parent->_col == RED) {
				Node* grandFather = parent->_parent;
				if (grandFather == nullptr) {
					break;
				}
				if (grandFather&&parent == grandFather->_left) {
					//    g
					//  p   u
					Node* uncle = grandFather->_right;
					//叔叔存在且为红，只需向上变色即可
					if (uncle && uncle->_col == RED) {
						parent->_col = BLACK;
						uncle->_col = BLACK;
						grandFather->_col = RED;
						//继续向上处理
						cur = grandFather;
						parent = grandFather->_parent;
					}
					//叔叔不存在或者为黑，需要旋转，不需要再向上处理
					else {
						if (cur == parent->_left) {
							//    g
							//  p   u
							//c
							RotateR(grandFather);
							parent->_col = BLACK;
							grandFather->_col = RED;
							break;
						}
						else if (cur == parent->_right){
							//    g
							//  p   u
							//   c
							RotateL(parent);
							RotateR(grandFather);
							cur->_col = BLACK;
							parent->_col = RED;
							grandFather->_col = RED;
							break;
						}
						else {
							assert(false);
						}
					}
				}
				else if (grandFather && parent == grandFather->_right) {
					//    g
					//  u   p
					Node* uncle = grandFather->_left;
					//叔叔存在且为红，只需向上变色即可
					if (uncle && uncle->_col == RED) {
						parent->_col = BLACK;
						uncle->_col = BLACK;
						grandFather->_col = RED;
						//继续向上处理
						cur = grandFather;
						parent = grandFather->_parent;
					}
					//叔叔不存在或者为黑，需要旋转，不需要再向上处理
					else {
						if (cur == parent->_left) {
							//    g
							//  u   p
							//    c
							RotateR(parent);
							RotateL(grandFather);
							parent->_col = RED;
							grandFather->_col = RED;
							cur->_col = BLACK;
							break;
						}
						else if (cur == parent->_right) {
							//    g
							//  u   p
							//        c
							RotateL(grandFather);
							parent->_col = BLACK;
							grandFather->_col = RED;
							break;
						}
						else {
							assert(false);
						}
					}
				}
				else {
					assert(false);
				}
			}
			_root->_col = BLACK;
			return std::make_pair(recur, true);
		}
		bool TestTree() {
			int refNum = 0;
			Node* cur = _root;
			while (cur) {
				if (cur->_col == BLACK) {
					refNum++;
				}
				cur = cur->_left;
			}
			return _TestTree(_root, refNum,0);
		}
	private:
		bool _TestTree(Node* root,int refNum,int BlackNum) {
			if (root == nullptr) {
				if (refNum != BlackNum) {
					std::cout << "存在黑色节点的数量不相等的路径" << std::endl;
					return false;
				}
				return true;
			}
			if (root->_col == BLACK) {
				BlackNum++;
			}
			if (root->_parent && root->_parent->_col == RED && root->_col == RED) {
				std::cout << "存在连续红节点" << std::endl;
				return false;
			}
			return _TestTree(root->_left, refNum, BlackNum)
				&& _TestTree(root->_right, refNum, BlackNum);
		}
		Node* _root = nullptr;
		void RotateL(Node* parent) {
			Node* nodeR = parent->_right;
			Node* nodeRL = nodeR->_left;
			if (nodeRL) {
				nodeRL->_parent = parent;
			}
			Node* ppNode = parent->_parent;
			if (ppNode) {
				if (ppNode->_left == parent) {
					ppNode->_left = nodeR;
					nodeR->_parent = ppNode;
				}
				else {
					ppNode->_right = nodeR;
					nodeR->_parent = ppNode;
				}
			}
			else {
				_root = nodeR;
				nodeR->_parent = nullptr;
			}
			nodeR->_left = parent;
			parent->_right = nodeRL;
			parent->_parent = nodeR;
		}
		void RotateR(Node* parent) {
			Node* nodeL = parent->_left;
			Node* nodeLR = nodeL->_right;
			if (nodeLR) {
				nodeLR->_parent = parent;
			}
			Node* ppNode = parent->_parent;
			if (ppNode) {
				if (ppNode->_left == parent) {
					nodeL->_parent = ppNode;
					ppNode->_left = nodeL;
				}
				else {
					nodeL->_parent = ppNode;
					ppNode->_right = nodeL;
				}
			}
			else {
				_root = nodeL;
				nodeL->_parent = nullptr;
			}
			parent->_left = nodeLR;
			parent->_parent = nodeL;
			nodeL->_right = parent;
		}
		/*void _order(Node* root) {
			if (root == nullptr) {
				return;
			}
			_order(root->_left);
			std::cout << root->_data << " ";
			_order(root->_right);
		}*/
	};
}


#pragma once
#include"Encapsulation_of_Map_and_Set.h"
using namespace yuan;
template<class T>
class MySet {
public:
	struct KeyOFSet {
		const T& operator()(const T& Key) {
			return Key;
		}
	};
	typedef typename RBTree<T, const T, KeyOFSet>::Iterator iterator;
	iterator begin() {
		return _root.begin();
	}
	iterator end() {
		return _root.end();
	}
	std::pair<iterator, bool> insert(const T& t) {
		return _root.insert(t);
	}
	iterator find(const T& t) {
		return _root.find(t);
	}
	bool testTree() {
		return _root.TestTree();
	}
private:
	RBTree<T,const T, KeyOFSet> _root;
};



#pragma once
#include"Encapsulation_of_Map_and_Set.h"
using namespace yuan;
template<class K,class V>
class MyMap {
	struct KeyOFMAP {
		const K& operator()(const std::pair<K, V>& p) {
			return p.first;
		}
	};
public:
		typedef typename RBTree<K, std::pair<const K, V>, KeyOFMAP>::Iterator iterator;
		iterator begin() {
			return _root.begin();
		}
		iterator end() {
			return _root.end();
		}
		std::pair<iterator,bool> insert(const std::pair<const K, V>& p) {
			return _root.insert(p);
		}
		iterator find(const K& t) {
			return _root.find(t);
		}
		V& operator[](const K& k) {
			std::pair<iterator,bool> temp=_root.insert(std::make_pair(k, V()));
			return temp.first->second;
		}
		bool testTree() {
			return _root.TestTree();
		}
private:
	RBTree<K, std::pair<const K, V>, KeyOFMAP> _root;
};



#include"Encapsulation_of_Map_and_Set.h"
#include"MySet.h"
#include"MyMap.h"
using namespace yuan;
void testSet() {
	MySet<int> s;
	s.insert(4);
	std::cout << s.testTree() << std::endl;
	s.insert(2);
	std::cout << s.testTree() << std::endl;
	s.insert(5);
	std::cout << s.testTree() << std::endl;
	s.insert(15);
	std::cout << s.testTree() << std::endl;
 	s.insert(7);
	std::cout << s.testTree() << std::endl;
	s.insert(1);
	std::cout << s.testTree() << std::endl;
	s.insert(5);
	std::cout << s.testTree() << std::endl;
	s.insert(7);
	MySet<int>::iterator it = s.begin();
	/*while (it != s.end()) {
		std::cout << *it << " ";
		++it;
	}*/
	/*for (int i = 0; i < 1000; i++) {
		
		std::cout << i << "->" << s.testTree() << std::endl;
	}*/
	std::cout << s.testTree() << std::endl;
}
void testMap() {
	MyMap<int, int> m1;
	std::srand(time(0));
	int temp;
	for (int i = 0; i < 10; i++) {
		temp = i + rand();
		m1[temp] = rand();
		//std::cout <<i<<"->"<< m1.testTree()<<std::endl;
	}
	MyMap<int, int>::iterator it = m1.begin();
	while (it != m1.end()) {
		if (it->first == 9) {
			int s = 0;
		}
		std::cout << it->first << " " << it->second << std::endl;
		it++;
	}
	///*++it;
	//std::cout<<m1.find(3)->second;*/
	//std::cout << m1[9] << std::endl; i << "->" 
	//std::cout << m1.testTree() << std::endl;
}
int main() {
	testMap();
	return 0;
}

yonlylove
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL库：map和set
修行的凡人的博客
11-14 3647
基于著名书籍和自我学习得出的map和set精华知识
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3153
红黑树详解
c++——map和set的封装
Britney_dark的博客
11-20 850
如果结果不如你所愿，就在尘埃落定前奋力一搏！
c++ map，set封装
2301_78323041的博客
05-12 893
map 是一个 kv 结构， set 是 k结构。我们前面模拟实现了 红黑树，但是我们实现的红黑树把 kv 结构写死了，怎么样才能用泛型编程的思想来实现map和set呢我们先简单看一下原码中是怎么实现的。
C++之map和set 的封装
qq_74732628的博客
05-13 931
文章详细讲解了map和set 的封装过程和底层原理
C++进阶之map与set
cls的博客
05-23 2698
stl中将数据结构叫做容器。 容器分为 序列式容器：vector/list... 就类似线性表 关联史容器：map/set.. 数据之间有强烈的关联性，底层是搜索树 栈和队列是适配器 set底层就是搜索树。 void test_set1() { //排序＋去重 set<int> s; s.insert(3); s.insert(1); s.insert(8); s.insert(2); s.insert(5); s.insert(5); s.insert(5)
C++：map和set的封装原理
海绵宝宝de派小星的博客
11-14 2466
map和set的模拟实现
map和set的异同
爱橙子的OK绷的专栏
03-12 7806
异同分析MAP的节点是一对数据. SET的节点是一个数据.map使用关键值Key来唯一标识每一个成员, map的value值可以重复。 set存储已排序的无重复的元素。都属于关联容器 ，形式不同：map的形式 map<type1, type2> mymap; set的形式 set<type> myset; set（集合）——包含了经过排序了的数据，这些数据的值(v
【C++】set和map
m0_62179366的博客
11-06 7412
map与set也十分的相似，map是K/V的模型，set是K的模型map也有两种区别与set和multiset相同，只是键值是否允许冗余的差别不过map的插入就比较特别了我们发现insert的参数是一个value_type类型然后我们发现它实际上是一个pair{T1 first;T2 second;{}{}};用来表示具有一一对应关系的一种结构，该结构中一般只包含两个成员变量key和value，key代表键值，value表示与key对应的信息。
C++：set和map的底层封装模拟实现
2301_76445610的博客
05-17 1066
底层对比：上图以kv模型为例。
map和set的模拟实现
06-06
本文将深入探讨如何通过封装红黑树来模拟实现Map和Set。 红黑树是一种自平衡二叉查找树，它的主要特性是每个节点都带有颜色属性（红色或黑色），并且遵循以下性质： 1. 每个节点要么是黑色，要么是红色。 2. 根节点...
哈希map以及set的封装
04-05
在这个场景中，我们讨论的是C++中的哈希表实现，即`哈希map`和`哈希set`的封装，它们是STL（标准模板库）的一部分，由`unordered_map`和`unordered_set`两个容器来表示。 首先，我们来看`哈希map`。`std::unordered...
红黑树封装实现map和set
06-20
封装红黑树实现map和set解决方案
c++容器list、vector、map、set区别与用法详解
12-17
c++容器list、vector、map、set区别 list 封装链表，以链表形式实现，不支持[]运算符。 对随机访问的速度很慢(需要遍历整个链表)，插入数据很快(不需要拷贝和移动数据，只需改变指针的指向)。 新添加的元素，...
14_L3缓存友好的数据结构
最新发布
刘炫320的博客
09-11 409
老鸟：L3缓存是CPU缓存层次结构中的第三层，通常比L1和L2缓存大，但访问速度稍慢。L3缓存友好的数据结构设计旨在最大限度地减少缓存未命中，从而提升性能。菜鸟：那这些数据结构有什么特点呢？老鸟：主要特点是数据局部性好，也就是说，数据在内存中是连续存储的，这样能更好地利用缓存行。我们可以从一个简单的例子开始，比如数组和链表的对比。老鸟：总结一下，L3缓存友好的数据结构通过提升数据局部性来提高性能。常见的有数组、等。它们在大数据处理和高性能计算中非常有用。但在实际应用中，需要权衡性能、可维护性和具体需求。
【数据结构】顺序表的应用
Sakura_ding的博客
09-07 483
2）能够保存用户信息：名字、性别、年龄、电话、地址等。1）至少能够存储100个⼈的通讯信息。
【数据结构】——1.1树
qq_43507078的博客
09-07 1045
树，二叉树
【数据结构】排序算法系列——希尔排序（附源码+图解）
Skrrapper的博客
09-07 934
希尔排序实际上是个相当复杂的排序算法，这主要是跟它的步长序列gap到底该如何取、后续应该减小有关。时，数组已经接近有序的了，就整体而言，最后一次整体的插入排序就可以大大提高效率——我们从插入排序的时间复杂度分析也可以看出，可以看到每次减小gap的规律是将原先的gap/2，但事实上这只是其中一种处理方法，并不说明这是最优解。，使得平均情况下的时间复杂度能够在O(n^1.3)左右，而不好的选择则可能导致接近最坏情况的性能。中，我们会将整体数据一分为多份，进行散布式的插入排序，这时候每一个子序列之间的间隙就是。
2.C_数据结构_线性表
Fresh_man111的博客
09-07 1077
线性表就是若干数据的一个线性序列。数学表达式：L：表名a0~an-1：数据元素n：表长，n>0是为非空表二元描述形式：D：数据元素D用 ai 表示，这个 i 范围是0~n-1R：关系用R表示，这个关系是，表示ai为ai+1的直接前驱，ai+1为ai的直接后继。：这符号称为有序对，xxx1是xxx2的直接前驱，xxx2是xxx1的直接后继。 xxx1和xxx2可以为一个或多个。
SolrTemplate query 返回结果封装为map集合
03-25
在上面的代码中，我们先定义了一个List<Map, Object>>类型的结果集，然后创建了一个Query对象，设置了查询条件、返回结果数量、排序方式和返回字段等参数。通过调用solrTemplate.query方法执行查询操作，得到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值