(第十步) STL: stl_binary_search_tree容器实现

最新推荐文章于 2022-04-14 07:00:05 发布
最新推荐文章于 2022-04-14 07:00:05 发布
阅读量164 收藏
点赞数 1
分类专栏： STL剖析 文章标签： stl 数据结构 二叉树 c++ visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38223012/article/details/119575893
版权

binary search tree

二叉搜索树性质挺简单的就不多说， 解决小问题，为后面的红黑树做个小铺垫
不过这里用到了string容器，之前设计的string存在点问题，就先拿std::string压压惊先了

binary search tree设计

  • empty() 树是否为空
  • erase(val) 删除指定元素
  • insert(val) 添加指定元素
  • size() 树上结点数量
  • depth() 返回树的深度
  • cbegin() 返回树的最小值迭代器
  • cend() 返回树的末尾迭代器
  • find(val) 寻找值
  • find_min() 寻找最小值
  • find_max() 寻找最大值
  • print_inorder() 打印中序遍历

迭代器相关：

重点是运算符的重载，这里实现了迭代器自加功能++it、it++，自减功能可以模仿写一个

binary_search_tree.h

#ifndef _BINARY_SEARCH_TREE_H_
#define _BINARY_SEARCH_TREE_H_

#include "../Includes/Allocator.h"
#include "../Includes/Iterator.h"
#include "../Includes/Algorithm.h"
#include "stl_queue.h"
#include "stl_stack.h"
#include <string>

#include <set>

namespace mySTL {
	namespace detail {
		template<class T>
		class bst_iter;
	}
	// 二叉搜索树
	//class of binary_search_tree
	template<class T>
	class binary_search_tree {
	private:
		template<class T>
		friend class detail::bst_iter;

	private:
		struct node {
			typedef T value_type;
			value_type data_;
			node* left_;
			node* right_;
			explicit node(T d = T(), node* l = 0, node* r = 0)
				:data_(d), left_(l), right_(r) {}
		};

		typedef mySTL::allocator<node> nodeAllocator;
	
	public:
		typedef T								value_type;
		typedef detail::bst_iter<node>			const_iterator;
		typedef const T& const_reference;
		typedef size_t							size_type;

	private:
		node* root_;
		size_t size_;

	public:
		binary_search_tree() :root_(0), size_(0) {}
		// 禁用copy构造
		binary_search_tree(const binary_search_tree&) = delete;
		binary_search_tree& operator=(const binary_search_tree&) = delete;

		~binary_search_tree();

		void insert(const T& val);
		template<class Iterator>
		void insert(Iterator first, Iterator last);
		void erase(const T& val);

		bool empty()const { return root_ == nullptr; }
		size_t size()const { return size_; }
		size_t depth()const { return depth_aux(root_); }
		const_iterator root()const { return const_iterator(root_, this); }

		const_iterator cbegin()const { return find_min(); }
		const_iterator cend()const { return const_iterator(0, this); }

		const_iterator find_min()const;
		const_iterator find_max()const;
		const_iterator find(const T& val)const;
		void print_inorder(const std::string& delim = " ", std::ostream& os = std::cout)const;
	
	private:
		void deallocateAllNodes(node* ptr);
		size_t depth_aux(node* p)const;
		void erase_elem(const T& val, node*& ptr);
		void insert_elem(const T& val, node*& ptr);
		const_iterator find_min_aux(const node* ptr)const;
		const_iterator find_max_aux(const node* ptr)const;
		const_iterator find_aux(const T& val, const node* ptr)const;
		void print_inorder_aux(const std::string& delim, std::ostream& os, const node* ptr)const;
	};//end of bst class


	// 迭代器
	namespace detail {
		//class of bst iterator
		template<class T>//T = node
		class bst_iter :public iterator<forward_iterator_tag, 
			typename ::mySTL::binary_search_tree<typename T::value_type>::value_type> {
		
		private:
			template<class T>
			friend class ::mySTL::binary_search_tree;

		private:
			typedef typename ::mySTL::binary_search_tree<typename T::value_type>::const_reference	const_reference;
			typedef const typename T::value_type*													const_pointer;
			typedef const ::mySTL::binary_search_tree<typename T::value_type>*						cntrPtr;
			
		private:
			const T* ptr;
			cntrPtr container_;				// 定义为二叉搜索树类型
			stack<const T*> parent;			// 保存从root到ptr的父节点的路径
			std::set<const T*> visited;		// 当前节点是否被访问过
											//（此node被访问说明其左子树已被访问了）

		public:
			bst_iter(const T* ptr, cntrPtr container);

			// 运算符重载
			operator const T* () { return ptr; }
			const_reference operator*()const { return ptr->data_; }
			const_pointer operator ->()const { return &(operator*()); }

			// 迭代器左右子树
			bst_iter left()const { return bst_iter(ptr->left_, container_); }
			bst_iter right()const { return bst_iter(ptr->right_, container_); }

			// ++iter iter++
			bst_iter& operator ++();
			bst_iter operator ++(int);

			// 应该还有--的重载

		public:
			template<class T>
			friend bool operator ==(const bst_iter<T>& it1, const bst_iter<T>& it2);
			template<class T>
			friend bool operator !=(const bst_iter<T>& it1, const bst_iter<T>& it2);
		};
		
		//end of bst_iter
	}
	
}

#include "../detail/stl_binary_search_tree.impl.h"

#endif

binary_search_tree.impl.h

#ifndef _BINARY_SEARCH_TREE_IMPL_H_
#define _BINARY_SEARCH_TREE_IMPL_H_
//#include "../p2_STL_Source/stl_binary_search_tree.h"

namespace mySTL {
	namespace detail {
		template<class T>
		 bst_iter<T>::bst_iter(const T* ptr, cntrPtr container)
			:ptr(ptr), container_(container)
		{
			if (ptr == nullptr) return;

			auto temp = container_->root_;	// 记录根节点

			// 没有找到对应结点
			// parent保存从root到ptr父节点的路径
			while (temp && temp->data_ != ptr->data_)
			{
				parent.push(temp);	// 储存节点
				// 搜索树，大往右子树，小往左子树
				// visited保存比ptr->data_值小的结点
				if (temp->data_ < ptr->data_)
				{
					//temp向右走说明temp指向的父节点不需要再次访问了
					visited.insert(temp);
					temp = temp->right_;
				}
				else if (temp->data_ > ptr->data_)
				{
					temp = temp->left_;
				}
			}

		}

		template<class T>
		 bst_iter<T>& bst_iter<T>::operator++()
		{
			visited.insert(this->ptr);//此node被访问

			if (this->ptr->right_)	// 有右节点
			{
				parent.push(ptr);
				ptr = ptr->right_;

				// 寻找右子树的最左结点，根据二叉搜索树性质可知
				// 即寻找在排序中，在ptr结点后的节点(后续结点)
				while (ptr != nullptr && ptr->left_ != nullptr)
				{
					parent.push(ptr);
					ptr = ptr->left_;
				}

			}
			else //node无右子树则只能向父节点路径移动
			{
				ptr = nullptr;

				while (!parent.empty())
				{
					ptr = parent.top();
					parent.pop();

					if (visited.count(ptr) == 0)// 父节点尚未访问,此时ptr指向此节点
					{
						visited.insert(ptr);
						break;
					}

					ptr = nullptr; // 设为哨兵
				}
			}

			return *this;


		}

		template<class T>
		 bst_iter<T> bst_iter<T>::operator++(int)
		{
			auto res = *this;
			++* this;
			return res;
		}

		template<class T>
		bool operator==(const bst_iter<T>& it1, const bst_iter<T>& it2)
		{
			return it1.ptr == it2.ptr;
		}
		template<class T>
		bool operator!=(const bst_iter<T>& it1, const bst_iter<T>& it2)
		{
			return !(it1 == it2);
		}
	}
	

	// 析构函数
	template<class T>
	 binary_search_tree<T>::~binary_search_tree()
	{
		deallocateAllNodes(root_);
	}

	template<class T>
	 void binary_search_tree<T>::deallocateAllNodes(node* ptr)
	{
		// 采用后序遍历递归，自下而上删除结点
		if (ptr != nullptr)
		{
			deallocateAllNodes(ptr->left_);
			deallocateAllNodes(ptr->right_);

			nodeAllocator::destroy(ptr);
			nodeAllocator::deallocate(ptr);
		}
	}

	

	// 插入和擦除
	template<class T>
	 void binary_search_tree<T>::insert(const T& val)
	{
		insert_elem(val, root_);
	}

	template<class T>
	template<class Iterator>
	 void binary_search_tree<T>::insert(Iterator first, Iterator last)
	{
		for (; first != last; ++first)
		{
			insert(*first);
		}
	}

	template<class T>
	 void binary_search_tree<T>::erase(const T& val)
	{
		erase_elem(val, root_);
	}

	

	// 查找函数
	template<class T>
	 typename binary_search_tree<T>::const_iterator binary_search_tree<T>::find_min() const
	{
		return find_min_aux(root_);
	}

	template<class T>
	 typename binary_search_tree<T>::const_iterator binary_search_tree<T>::find_max() const
	{
		return find_max_aux(root_);
	}

	template<class T>
	 typename binary_search_tree<T>::const_iterator binary_search_tree<T>::find(const T& val) const
	{
		return find_aux(val, root_);
	}

	// 遍历 中序
	

	template<class T>
	 void binary_search_tree<T>::print_inorder(const std::string& delim, std::ostream& os) const
	{
		print_inorder_aux(delim, os, root_);
	}


	// 辅助函数
	template<class T>
	 size_t binary_search_tree<T>::depth_aux(node* p) const
	{
		if (p == nullptr) return 0;
		auto leftDepth = depth_aux(p->left_);
		auto rightDepth = depth_aux(p->right_);

		return 1 + max(leftDepth, rightDepth);
	}

	template<class T>
	 void binary_search_tree<T>::insert_elem(const T& val, node*& ptr)
	{
		if (ptr == nullptr)
		{
			ptr = nodeAllocator::allocate();
			nodeAllocator::construct(ptr);

			ptr->data_ = val;
			ptr->left_ = ptr->right_ = nullptr;
			++size_;
		}
		else
		{
			if (val < ptr->data_) 
			{
				return insert_elem(val, ptr->left_);
			}
			else if (val > ptr->data_) 
			{
				return insert_elem(val, ptr->right_);
			}
		}
	}

	template<class T>
	 void binary_search_tree<T>::erase_elem(const T& val, node*& ptr)
	{
		// 在删除结点中，并没有涵盖所有可能，存在一些问题
		if (ptr == nullptr)
			return;
		if (ptr->data_ != val) 
		{
			if (val < ptr->data_)
				return erase_elem(val, ptr->left_);
			else
				return erase_elem(val, ptr->right_);
		}
		else
		{
			if (ptr->left_ != 0 && ptr->right_ != 0) 
			{	// 有两个子节点时
				size_t choose = size_ % 2;
				// 随机选择，选择1前继结点，0后继结点
				// 左子数最大为前继，右子树最小为后继
				auto pos = (choose == 0 ?
					const_cast<node*>(find_min_aux(ptr->right_).ptr) : const_cast<node*>(find_max_aux(ptr->left_).ptr));

				ptr->data_ = pos->data_;
				return (choose == 0 ? erase_elem(pos->data_, ptr->right_) : erase_elem(pos->data_, ptr->left_));
			}
			else 
			{ // 有一个或没有子节点
				auto temp = ptr;
				if (ptr->left_ == nullptr)
					ptr = ptr->right_;
				else
					ptr = ptr->left_;
				nodeAllocator::destroy(temp);
				nodeAllocator::deallocate(temp);
				--size_;
			}
		}
	}

	template<class T>
	 typename binary_search_tree<T>::const_iterator binary_search_tree<T>::find_min_aux(const node* ptr) const
	{
		while (ptr && ptr->left_ != 0) {
			ptr = ptr->left_;
		}
		return const_iterator(ptr, this);
	}

	template<class T>
	typename binary_search_tree<T>::const_iterator binary_search_tree<T>::find_max_aux(const node* ptr) const
	{
		while (ptr && ptr->right_ != 0) {
			ptr = ptr->right_;
		}
		return const_iterator(ptr, this);
	}

	template<class T>
	typename binary_search_tree<T>::const_iterator binary_search_tree<T>::find_aux(const T& val, const node* ptr) const
	{
		while (ptr) {
			if (val == ptr->data_)
				break;
			else if (val < ptr->data_)
				ptr = ptr->left_;
			else
				ptr = ptr->right_;
		}
		return const_iterator(ptr, this);
	}


	template<class T>
	 void binary_search_tree<T>::print_inorder_aux(const std::string& delim, std::ostream& os, const node* ptr) const
	{
		if (ptr) {
			print_inorder_aux(delim, os, ptr->left_);
			os << ptr->data_ << delim;
			print_inorder_aux(delim, os, ptr->right_);
		}
	}

}



#endif

binary_search_tree_test.h

#ifndef _BINARY_SEARCH_TREE_TEST_H_
#define _BINARY_SEARCH_TREE_TEST_H_


#include "../p2_STL_Source/stl_binary_search_tree.h"

#include <algorithm>
#include <cassert>
#include <random>
#include <string>
#include <vector>

namespace mySTL {
	namespace binarySearchTreeTest {
		template<class T>
		using tsBst = mySTL::binary_search_tree < T >;

		void test01();
		void test02();
		void test03();
		void test04();
		void test05();
	}
}

#endif

binary_search_tree_test.cpp

#include "stl_binary_search_tree_test.h"

using namespace std;
#include <time.h>

namespace mySTL {
	namespace binarySearchTreeTest {

		template<class Container1, class Container2>
		bool container_equal(const Container1& con1, const Container2& con2) {
			auto first1 = con1.cbegin(), last1 = con1.cend();
			auto first2 = con2.cbegin(), last2 = con2.cend();
			for (; first1 != last1 && first2 != last2; ++first1, ++first2) {
				if (*first1 != *first2)
					return false;
			}
			return (first1 == last1 && first2 == last2);
		}


		void test01()
		{
			tsBst<std::string> bst;

			cout << "tree is empty: " << boolalpha << bst.empty() << endl;
			cout << "tree size is : " << bst.size() << endl;

			bst.insert("1");
			assert(!bst.empty());
			cout << "tree is empty: " << boolalpha << bst.empty() << endl;
			cout << "tree size is : " << bst.size() << endl;
		}

		void test02()
		{
			tsBst<int> bst;

			for (auto i = 0; i != 100; ++i)
				bst.insert(i);
			cout << "tree depth is :" << bst.depth() << endl;
		}

		void test03()
		{
			srand(time(NULL));
			tsBst<int> bst;
			for (auto i = 0; i != 10; ++i)
				bst.insert(rand() % 50);

			bst.insert(5);

			cout << "中序遍历:";
			bst.print_inorder();
			cout << endl;
			cout << "查找5：" << *bst.find(5) << endl;
			cout << "查找最小：" << *bst.find_min() << endl;
			cout << "查找最大：" << *bst.find_max() << endl;



		}

		void test04()
		{
			tsBst<int> bst;
			std::vector<int> v;
			std::random_device rd;

			for (auto i = 0; i != 20; ++i) {
				auto r = rd() % 65536;
				bst.insert(r);
				v.push_back(r);
			}
			std::sort(v.begin(), v.end());
			v.erase(std::unique(v.begin(), v.end()), v.end());

			cout << "vector sort: \t";
			for (int i = 0; i < v.size(); i++)
			{
				cout << v[i] << " ";
			}
			cout << endl;

			cout << "binary search tree :";
			bst.print_inorder();
			cout << endl;


			cout << "-----------erase---------------" << endl;
			for (auto i = 0; i != 5; ++i) {
				bst.erase(*bst.cbegin());
				v.erase(v.begin());
			}
			cout << "vector sort: \t";
			for (int i = 0; i < v.size(); i++)
			{
				cout << v[i] << " ";
			}
			cout << endl;

			cout << "binary search tree :";
			bst.print_inorder();
			cout << endl;
		}

		void test05()
		{
			std::random_device rd;
			tsBst<int> bst;

			for (int i = 0; i != 10; ++i)
			{
				bst.insert(rd() % 100);
			}

			cout << "binary search tree :";
			bst.print_inorder();
			cout << endl;

			cout << "bst begin node:" <<  *bst.cbegin() << endl;
			
			cout << "test it++ func:";
			for (auto it = bst.cbegin(); it != bst.cend(); ++it)
			{
				cout << *it << " ";
			}
			cout << endl;
		}

	}
}
浊酒x
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL binary_search二分查找算法
JIWilliams
12-12 567
前面讲到的搜索算法都是对序列进行顺序搜索，而且没有事先对元素进行排序的要求。二分查找一般比顺序搜索要快，但要求序列中的元素是有序的。这主要是因为二分查找的搜索机制，图 1 说明了这种机制。 图1 二分查找 图 1 展示了在一个升序序列中二分查找 22 的过程。因为元素是升序排列的，所以查找机制使用小于运算符来查找元素。搜索降序序列需要使用小于运算符来比较元素。二分查找总是选择从序列中部的元素...
心希盼 C++ STL binaryTree
10-24
心希盼 C++ STL 二叉树 详细请看“心希盼 binaryTree.doc”
STL文件ASCII格式和二进制Binary格式读写操作C++代码实现
小强的机器人工坊
05-08 2244
//STLReader.h #ifndef STLREADER_H #define STLREADER_H #include <string> #include <vector> #include <array> #include <PQP.h> class STLReader { public: using ScalarType = double; //using ScalarType = float using Vector3 = st
模仿STL，实现二叉搜索数，带迭代器 BinSearchTree (iterator)
饭团爸爸的博客
02-25 727
自己看着书，实现的，废话不多说，上代码 转载请注明出处 #include #include #include #include using namespace std; template class BinSearchTreee; //下面是对于树节点的声明和定义 template class Tree_Node { private:
经典基础算法之BST详解（系列二）
weixin_30802273的博客
08-18 307
4. 二叉查找树(BST) Technorati 标记: 二叉查找树,BST,二叉查找树合并 4.1 BST数据结构定义 使用C++语言，如果需要使用BST，那么不用重新造轮子了，C++语言里的map, set等STL容器应该可以满足需求了（虽然STL里这些容器大多是以红黑树作为其底层实现），如果你需要使用小/大根堆（也叫优先队列，特殊的、自平衡的BST），STL也能满足你的需求（可以参考这...
hongheishu.rar_binary tree_红黑树
最新发布
09-21
红黑树（Red-Black Tree）是一种自平衡的二叉查找树，由Rudolf Bayer在1972年提出，它的设计目标是为了在插入、删除和查找等操作时保持较好的性能。红黑树的名字来源于它节点的颜色属性，每个节点可以是红色或黑色。...
LeetCode解决方案：:white_medium_star:LeetCode解决方案按类别分组:white_medium_star:
01-30
如“Binary Tree Inorder Traversal”要求实现二叉树的中序遍历，可以采用递归或栈来解决。 5. **堆**：堆是一种特殊的树形数据结构，常用于实现优先队列。例如，“Kth Largest Element in an Array”可以使用大...
boost_1_68_0 binary
11-22
4. **容器** (Containers)：例如`multi_array`, `property_tree`等，扩展了标准模板库（STL）的容器。 5. **函数对象** (Function Objects)：包括函数包装器、函数适配器等，方便函数作为对象进行操作。 6. **正则...
binarytree.rar_数据结构_Visual_C++_
08-12
在本项目"binarytree.rar_数据结构_Visual_C++_"中，我们将重点讨论如何在Visual C++环境下实现二叉树的相关功能。 二叉树是由节点构成的数据结构，每个节点包含两个指向其他节点的指针，通常称为左孩子和右孩子。...
binary-tree.zip_数据结构_Visual_C++_
08-11
在本项目"binary-tree.zip_数据结构_Visual_C++_"中，我们关注的是使用C/C++语言在Visual C++环境下实现二叉树的基本操作。下面我们将深入探讨二叉树的概念、存储方式以及常见的操作。 二叉树是一种特殊的树形数据...
泛型的Binary Search Tree的实现，并与STL map进行操作性能上的比较
manthink2005的专栏
04-28 1014
泛型的Binary Search Tree的实现，并与STL map进行操作性能上的比较
STL两种格式：文本格式与二进制格式
weiyiwen1982的博客
04-14 8909
STL格式在有限元前处理中具有重要应用。利用GMSH中的MERGE可以实现多个面的拼接，接着可以快速实现3D网格剖分。以此，加快建模过程。
[数据结构]——二叉树（Binary Tree）、二叉搜索树（Binary Search Tree）及其衍生算法...
weixin_30362233的博客
12-21 193
二叉树（Binary Tree）是最简单的树形数据结构，然而却十分精妙。其衍生出各种算法，以致于占据了数据结构的半壁江山。STL中大名顶顶的关联容器——集合（set）、映射（map）便是使用二叉树实现。由于篇幅有限，此处仅作一般介绍（如果想要完全了解二叉树以及其衍生出的各种算法，恐怕要写8~10篇）。 1）二叉树（Binary Tree） 顾名思义，就是一个节点分出两个节点，称其为左右子节点；...
stl格式说明和stl文件生成（ascII，binary），vs2005，文件生成后imageware读取成功
junpengxue的专栏
08-13 3573
1引言 STL(Stereo lithographic)文件格式是美国3D SYSTEMS公司提出的三维实体造型系统的一个接口标准，其接口格式规范。采用三角形面片离散地近似表示三维模型，目前已被工业界认为是快速成形(rapid prototypi ng)领域的标准描述文件格式。在逆向工程、有限元分析、医学成像系统、文物保护等方面有广泛的应用。 STL文件的最大特点也是其主要问题是，它是由一系列
C++之STL文件二进制格式转ASCII格式
qq_51290192的博客
06-21 2512
C++之STL文件二进制格式转ASCII格式 1、STL文件 STL文件是一种用许多空间小三角形面片逼近三维实体表面的数据模型，STL模型的数据通过给出组成三角形法向量的3个分量(用于确定三角面片的正反方向)及三角形的3个顶点坐标来实现，一个完整的STL文件记载了组成实体模型的所有三角形面片的法向量数据和顶点坐标数据信息。目前的STL文件格式包括二进制文件(BINARY)和文本文件(ASCII)两种。 1.1、STL的二进制格式 文件起始的80个字节是文件头，用于存贮零件名；紧接着用4个字节的整数来描述模型
C++ 二叉树（BinaryTree）的基本操作
ChanJose的博客
01-14 4406
一、实现程序 // 题目：实现二叉树的各种操作 // 测试数据：1 2 # 3 # # 4 5 # # 6 # # #include &lt;iostream&gt; #include &lt;queue&gt; #include &lt;stack&gt; template&lt;class T&gt; struct Node { T data; Node *next;...
数据结构STL基础之树和二叉树
Maushawkin的博客
11-17 1322
树和二叉树1 基础概念:1.1 度和深度1.2 二叉数性质1.3 哈夫曼编码与哈夫曼树2 代码实现2.1 创建二叉树 与 三种遍历 1 基础概念: 1.1 度和深度 结点的度: 其子结点的数量 树的度: 最大的结点的度 树的深度: 从根算起的层数 性质: 树上任意两个结点路径唯一(无环) 非空树必有一个根结点与叶结点 树的边数+1 = 树的结点数 1.2 二叉数性质 二叉树: 叶结点 = 度为2结点+1 // N代表总边数, n代表结点数 边等式: N = 2 * n2 + n1 结点与边等式: N
C++ Binary Tree(二叉树)
a130737的专栏
07-19 4371
一个二叉树是有节点（）组成的。
C++奇技淫巧&黑科技 之 自定义二元操作符（二目运算符） user defined binary operator in C++
MarkCoder的博客
10-17 823
C++奇技淫巧&黑科技 之 自定义二元操作符（二目运算符） user defined binary operator in C++一、前言1、缘起2、简介3、作用①向量叉乘（cross）与点乘（dot）的传统写法②使用自定义二元操作符的写法二、简易实现1、思路2、简易实现 `1 2`①运算顺序②定义class Oper③重载大于小于④完整代码三、模板实现1、实作代码2、实作向量加法、叉乘和点乘四、尾记 一、前言 1、缘起 很早之前，有看到boost中似乎有 a <oper> b
"STL关联容器概述：序列式容器与关联式容器的区别及底层实现
底层实现上，STL关联容器通常使用二叉搜索树（Binary Search Tree）作为其存储结构。二叉搜索树是一种特殊的二叉树，具有以下特性：如果左子树不为空，则左子树所有节点的值都小于根节点的值；如果右子树不为空，则...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值