STL之set和map

最新推荐文章于 2024-07-25 18:34:51 发布
最新推荐文章于 2024-07-25 18:34:51 发布
阅读量279 收藏
点赞数
分类专栏： 数据结构 一块来学C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60880296/article/details/131322883
版权

目录

一. 原型

  • 简单实现的红黑树
template<class K, class V>
struct RBTreeNode
{
    RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
    
	pair<K, V> _kv;
	Colour _col;
};

template<class K, class V>
struct RBTree
{
    typedef RBTreeNode<K, V> Node;
public:
    bool Insert(const pair<K, V>& kv);
    Node* Find(const K& key); 
private:
	Node* _root = nullptr;
};
  • set
template<class K>
class set
{
private:
    RBTree<K, K> _t;
};
  • map
template<class K, class V>
class map
{
private:
    RBTree<K, V> _t;
};

二. 模板参数适配

  • 红黑树
template<class T>
struct RBTreeNode
{
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;

	T _data;
	Colour _col;
};

template<class K, class T, class KeyOfT>
struct RBTree
{
    typedef RBTreeNode<T> Node;
public:
    bool Insert(const T& data);
    Node* Find(const K& key);     
private:
	Node* _root = nullptr;
}
  • set
template<class K>
class set
{
    //仿函数
    struct SetKeyOfT//返回K对象的key
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
private:
    RBTree<K, K, SetKeyOfT> _t;
};
  • map
template<class K, class V>
class map
{
	struct MapKeyOfT//返回pair<K,V>对象的key
	{
		const K& operator()(const pair<K, V>& kv)
		{
			return kv.first;
		}
	};
private:
    RBTree<K, pair<K,V>, MapKeyOfT> _t;
};

在这里插入图片描述

红黑树作为底层结构而言，它不能够区分使用者是set还是map。

class K：表示键值类型

class T：表示存储类型

class KeyOfT：仿函数，用于从T类型中提取K键值

对于set容器，底层存储K类型元素，键值也为K

对于map容器，底层存储<K,V>键值对，键值为K

三. 迭代器

设计迭代器，方便遍历，让用户在使用时不需要在意底层实现。

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

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

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

template<class K, class T, class KeyOfT>
struct RBTree
{
	typedef __RBTreeIterator<T, T&, T*> iterator;
public:
    // 最左节点
    iterator begin()
	{
		Node* left = _root;
		while (left && left->_left)
		{
			left = left->_left;
		}

		return iterator(left);
	}
	// 最后一个节点的下一个位置
	iterator end()
	{
		return iterator(nullptr);
	}
};

在这里插入图片描述

  1. operator++()

步骤：

  • 右子树不为空，++就是找右子树中序第一个(最左节点)
  • 右子树为空，++找孩子不是父亲右的那个祖先
Self& operator++()
{
    if (_node->_right)
    {
        // 下一个就是右子树的最左节点
        Node* left = _node->_right;
        while (left->_left)
        {
            left = left->_left;
        }

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

        _node = parent;
    }

    return *this;
}
  1. operator--()

与++相反，步骤：

  • 左子树不为空，–就是找左子树的最右节点
  • 左子树为空，–找孩子不是父亲的左的那个祖先
Self& operator--()
{
    if (_node->_left)
    {
        // 下一个是左子树的最右节点
        Node* right = _node->_left;
        while (right->_right)
        {
            right = right->_right;
        }

        _node = right;
    }
    else
    {
        // 孩子不是父亲的左的那个祖先
        Node* parent = _node->_parent;
        Node* cur = _node;
        while (parent && cur == parent->_left)
        {
            cur = cur->_parent;
            parent = parent->_parent;
        }

        _node = parent;
    }

    return *this;
}

四. 插入函数的修改

pair<iterator, bool> Insert(const T& data)
{
    KeyOfT kot;//仿函数，获取键值

    if (_root == nullptr)//空树，让新节点为根节点
    {
        _root = new Node(data);
        _root->_col = BLACK;
        return make_pair(iterator(_root), true);;
    }

    //插入新节点
    Node* cur = _root;//当前节点
    Node* parent = nullptr;//cur的父节点
    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;//标记新节的

    if (kot(parent->_data) < kot(data))//新节点的键值大于parent
    {
        parent->_right = cur;//放在parent的右边
    }
    else
    {
        parent->_left = cur;//左边
    }
    cur->_parent = parent;

    // 调整
    //（cur最差会遍历到根节点）p为红色
    while (parent && parent->_col == RED)
    {
        Node* grandfater = parent->_parent;//parent的父节点

        // 关键看叔叔
        if (parent == grandfater->_left)//p是g的左孩子
        {
            Node* uncle = grandfater->_right;//叔叔节点

            // 情况一 : u为红，
            if (uncle && uncle->_col == RED)
            {
                // 变色
                parent->_col = uncle->_col = BLACK;
                grandfater->_col = RED;
                // 继续往上处理
                cur = grandfater;
                parent = cur->_parent;
            }
            else// 情况二：u为黑
            {
                if (cur == parent->_left)//c为p的左孩子
                {
                    // 右单旋+变色
                    //     g 
                    //   p   u
                    // c
                    RotateR(grandfater);//右旋
                    parent->_col = BLACK;
                    grandfater->_col = RED;
                }
                else//c为p的右孩子
                {
                    //  左右单旋+变色
                    //     g 
                    //   p   u
                    //     c
                    RotateL(parent);//左旋
                    RotateR(grandfater);//右旋
                    cur->_col = BLACK;
                    grandfater->_col = RED;
                }
                break;//结束
            }
        }
        else // (parent == grandfater->_right) //p是g的右孩子
        {
            Node* uncle = grandfater->_left;//叔叔节点

            // 情况一 : u为红，
            if (uncle && uncle->_col == RED)
            {
                // 变色
                parent->_col = uncle->_col = BLACK;
                grandfater->_col = RED;
                // 继续往上处理
                cur = grandfater;
                parent = cur->_parent;
            }
            else//情况二 : u为黑，
            {
                if (cur == parent->_right)//c为p的右孩子
                {
                    // 左单旋+变色
                    //     g 
                    //   u   p
                    //         c
                    RotateL(grandfater);//左旋
                    parent->_col = BLACK;
                    grandfater->_col = RED;
                }
                else// c为p的左孩子
                {
                    // 情况三：右左单旋+变色
                    //     g 
                    //   u   p
                    //     c
                    RotateR(parent);//右旋
                    RotateL(grandfater);//左旋
                    cur->_col = BLACK;
                    grandfater->_col = RED;
                }
                break;//结束
            }
        }
    }
    _root->_col = BLACK;//根节点颜色为黑色(可能在情况一下被修改）

    return make_pair(iterator(newnode), true);
}

将Insert()的返回值改为pair<iterator, bool>的形式，主要是为了实现map中的operator[]

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

四. 代码

  • 红黑树
#pragma once
enum Colour
{
	RED,
	BLACK
};

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

	T _data;
	Colour _col;

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

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

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

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

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

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

			_node = parent;
		}

		return *this;
	}

	Self& operator--()
	{
		if (_node->_left)
		{
			// 下一个是左子树的最右节点
			Node* right = _node->_left;
			while (right->_right)
			{
				right = right->_right;
			}

			_node = right;
		}
		else
		{
			// 孩子不是父亲的左的那个祖先
			Node* parent = _node->_parent;
			Node* cur = _node;
			while (parent && cur == parent->_left)
			{
				cur = cur->_parent;
				parent = parent->_parent;
			}

			_node = parent;
		}

		return *this;
	}
};

template<class K, class T, class KeyOfT>
struct RBTree
{
	typedef RBTreeNode<T> Node;
	typedef __RBTreeIterator<T, T&, T*> iterator;

public:

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

		return iterator(left);
	}

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

	pair<iterator, bool> Insert(const T& data)
	{
		KeyOfT kot;

		if (_root == nullptr)//空树，让新节点为根节点
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return make_pair(iterator(_root), true);;
		}

		//插入新节点
		Node* cur = _root;//当前节点
		Node* parent = nullptr;//cur的父节点
		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;//标记新节的

		if (kot(parent->_data) < kot(data))//新节点的键值大于parent
		{
			parent->_right = cur;//放在parent的右边
		}
		else
		{
			parent->_left = cur;//左边
		}
		cur->_parent = parent;

		// 调整
		//（cur最差会遍历到根节点）p为红色
		while (parent && parent->_col == RED)
		{
			Node* grandfater = parent->_parent;//parent的父节点

			// 关键看叔叔
			if (parent == grandfater->_left)//p是g的左孩子
			{
				Node* uncle = grandfater->_right;//叔叔节点

				// 情况一 : u为红，
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
					// 继续往上处理
					cur = grandfater;
					parent = cur->_parent;
				}
				else// 情况二：u为黑
				{
					if (cur == parent->_left)//c为p的左孩子
					{
						// 右单旋+变色
						//     g 
						//   p   u
						// c
						RotateR(grandfater);//右旋
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					else//c为p的右孩子
					{
						//  左右单旋+变色
						//     g 
						//   p   u
						//     c
						RotateL(parent);//左旋
						RotateR(grandfater);//右旋
						cur->_col = BLACK;
						grandfater->_col = RED;
					}
					break;//结束
				}
			}
			else // (parent == grandfater->_right) //p是g的右孩子
			{
				Node* uncle = grandfater->_left;//叔叔节点

				// 情况一 : u为红，
				if (uncle && uncle->_col == RED)
				{
					// 变色
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
					// 继续往上处理
					cur = grandfater;
					parent = cur->_parent;
				}
				else//情况二 : u为黑，
				{
					if (cur == parent->_right)//c为p的右孩子
					{
						// 左单旋+变色
						//     g 
						//   u   p
						//         c
						RotateL(grandfater);//左旋
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					else// c为p的左孩子
					{
						// 情况三：右左单旋+变色
						//     g 
						//   u   p
						//     c
						RotateR(parent);//右旋
						RotateL(grandfater);//左旋
						cur->_col = BLACK;
						grandfater->_col = RED;
					}
					break;//结束
				}
			}
		}
		_root->_col = BLACK;//根节点颜色为黑色(可能在情况一下被修改）

		return make_pair(iterator(newnode), true);
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

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

		if (_root->_col == RED)
		{
			cout << "根节点不是黑色" << endl;
			return false;
		}

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

		return PrevCheck(_root, 0, benchmark);
	}

private:
	// 休息21：18继续
	bool PrevCheck(Node* root, int blackNum, int& benchmark)
	{
		if (root == nullptr)//路径走完，到空节点
		{
			//benchark更新为第一条路径上黑色节点的数量
			if (benchmark == 0)
			{
				benchmark = blackNum;
				return true;
			}

			if (blackNum != benchmark)
			{
				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 PrevCheck(root->_left, blackNum, benchmark)
			&& PrevCheck(root->_right, blackNum, benchmark);
	}

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

		_InOrder(root->_left);
		cout << kot(root->_data) << ":" << root->_data << endl;
		_InOrder(root->_right);
	}

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

			subL->_parent = ppNode;
		}

	}

private:
	Node* _root = nullptr;
};
  • set
#pragma once

#include "RBTree.h"

template<class K>
class set
{
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	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;
};
  • map
#pragma once

#include "RBTree.h"

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

🦀🦀观看~~

异样旧日
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL之map
tromaker3的博客
03-24 84
#include <iostream> #include <map> #include <string> #include <cstring> #include <cstdio> using namespace std; typedef map<int,string> UDT_MAP_INT_CSTRING; UDT_MAP...
STL之map类
从早学到晚
08-14 171
MAP 本文讲map和unordered_map 一.解释： map 是一种有序无重复的关联容器。 关联容器与顺序容器不同，他们的元素是按照关键字来保存和访问的，而顺序元素是按照它们在容器中的位置保存和访问的。 map保存的是一种 key - value 的pair对象，其中 key 是关键字，value 是关键字对应的值。通过 key找到对应的 value。map中按照 key的大小升序排列pa...
【C++】--- STL之 set 和 map
weixin_75128035的博客
05-30 1021
multimap容器与map容器的底层实现一样，也都是平衡搜索树（红黑树），其次，multimap容器和map容器所提供的成员函数的接口都是基本一致的，这里也就不再列举了，multimap容器和map容器的区别与multiset容器和set容器的区别一样，multimap允许键值冗余，即。比如：现在要建立一个英汉互译的字典，那该字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应该单词，在词典中就可以找到与其对应的中文含义。是最常用的，也是最简洁的！
STL详解---set和map
分享学习的知识，记录我的技术成长道路
05-31 1243
在我们之前的学习中，已经了解了STL的部分容器，比如：vector，list，deque，forward_list等等，这些容器统称为序列式容器，而我们今天要将的map和set称之为关联式容器，序列式容器和关联式容器的区别就在于，序列式容器单纯为了存储数据而存在。而关联式容器不仅仅存储数据还对结构进行了存储。 在了解set和map之前，我们需要了解搜索二叉树是什么，因为set和map的底层就是一棵搜索二叉树。
浅析stl序列容器(map和set)的仿函数排序
09-05
在本文中，我们将深入探讨如何使用仿函数对STL序列容器`map`和`set`进行自定义排序。 `set`和`map`都是STL中有序的容器。`set`是一个无重复元素的集合，而`map`则是一组键值对，其中键是唯一的。它们都使用红黑树...
windbg导出stl map和set的插件
07-28
在处理复杂的系统问题时，尤其是对于C++程序中的STL（Standard Template Library，标准模板库）容器，如map和set，理解其内部结构和内容至关重要。这个插件“stlkit.dll”就是为了帮助开发者更便捷地在Windbg中查看...
map和set的模拟实现
06-06
通过这样的实现，我们能够获得与STL中map和set类似的功能，同时可以根据具体需求进行定制，例如优化比较函数、添加额外的成员函数或改变内存管理策略。 在实际编码过程中，可以参考开源的红黑树实现，如Linux内核中...
stl容器set,map,vector之erase用法与返回值详细解析
09-05
在STL容器中，`set`、`map`和`vector`是最常用的三种，它们各自有着不同的特性。本文将详细解析这三种容器中`erase`函数的用法及其返回值。 1. **list::erase** `list`是一个双向链表，它的`erase`函数可以接受一...
STL基础栈链表map set
11-03
在本篇内容中，我们将详细介绍STL中的几个基本概念：栈（Stack）、链表（List）、map、set。 ### 栈（Stack） #### 定义与特性 栈是一种特殊的线性表，其特点是只能在表的一端进行插入和删除操作，遵循后进先出...
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 395
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
《Cross-Modal Dynamic Transfer Learning for Multimodal Emotion Recognition》
buyaotutou的博客
07-25 1134
例如：第一章 Python 机器学习入门之pandas的使用文章链接Multimodal Emotion Recognition is an important research area for developing human-centric applications, especially in the context of video platforms. Most existing models have attempted to develop sophisticated fusion tech
背单词工具(C++)
zeyeqianli的博客
07-24 3345
【代码】背单词工具(C++)
C++ //练习 15.28 定义一个存放Quote对象的vector，将Bulk_quote对象传入其中。计算vector中所有元素总的net_price。
Made in Code
07-25 614
C++ Primer（第5版） 练习 15.28
C语言100基础拔高题（3）
2303_78660417的博客
07-23 962
解题思路：通过switch语句来判断第一个字母，如果遇到字母相同的，在case语句中继续使用if语句来进行第二个字母的判断。解题思路：首先通过判断得出它是几位数，接着有几位数就输出几次，每次都输出最右边的数字。解题思路：我们这里假设它是按照从小到大的顺序进行排序，首先判断它是否大于最右边的数，如果小于，则考虑插入到中间的情况。解题思路：质数又称素数，有无限个。解题思路：通过设置一个新数组，来接收除了要删除字母以外的其他字母。解题思路：得到输入的5位数的个位，十位，千位，万位上的数字，再对其进行比较。
C++基础（4.内存管理）
最新发布
2301_79903399的博客
07-25 343
对于p2和p3开辟的空间如同，开辟空间后对p3来说返回的位置如图（因为p2没有写析构函数同时也没有动态申请的空间需要析构于是编译器就优化掉了，对于p2的delete也就没有问题）。当时对于p3来说在头部有额外开辟的空间 ，加了方括号才会向前偏移到正确的位置释放，而不加方括号就会在如图位置析构一次，而开辟的空间是不能部分析构的所以会报错。对于new申请的空间如果失败了那么就会抛异常跳过后面的代码。对于写了析构函数的类系统在开空间时候会在头上多开4个字节来记录个数来调用析构函数。
C语言系统调用linux文件系统
C or CPP
07-25 797
在C语言中，openwrite和read函数是系统调用（system calls），它们直接由操作系统提供，用于底层的文件操作。这些函数是UNIX和类UNIX系统（如Linux）中的标准接口，不同于C标准库中的文件操作函数（如fopenfwrite和fread。
UE5 C++跑酷练习（Part2）
m0_64217692的博客
07-23 624
一.首先GameMode里有Actor数组，组装直线路，和左右路。
C++五子棋（未做完，但能玩，而且还不错）
LiXinLong_LXL_13的博客
07-23 3798
代码放下面了，关于步骤介绍的我以后再完善一下。
STL MAP, STL SET 数据结构基础及优势分析
STL MAP, STL SET 是C++中非常重要的数据结构之一，它们提供了非常方便的操作接口，使得在C++中可以非常方便地实现对于有序和无序关联数据的存储和操作。本文通过列举一些基本的问题，以及对这些问题的解答，来讲解...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值