C++二叉搜索树(插入_删除(替换法)_查找_遍历_二叉搜索树检查)_二叉链递归与三叉链非递归

最新推荐文章于 2022-04-11 12:01:59 发布
最新推荐文章于 2022-04-11 12:01:59 发布
阅读量493 收藏 2
点赞数 5
分类专栏： C++ # 数据结构考研学习 文章标签： c++ leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dodamce/article/details/121593212
版权

文章目录

1.二叉链形式递归

#pragma once
#include<iostream>

using namespace std;

template<class Key,class Value>
struct BSTreeNode
{
	BSTreeNode<Key,Value>* _left;
	BSTreeNode<Key,Value>* _right;
	Key _key;
	Value _val;
	BSTreeNode(const Key& key, const Value& val)
		:_left(nullptr), _right(nullptr), _key(key), _val(val)
	{}
};

namespace MyR_KeyValue
{
	template<class Key,class Value>
	class BSTree
	{
		typedef BSTreeNode<Key,Value> Node;
	public:
		BSTree()
			:_root(nullptr)
		{}

		~BSTree()
		{
			Destory();
			_root = nullptr;
		}

		//拷贝构造函数(深拷贝)
		BSTree(const BSTree<Key,Value>& dev)
		{
			_root = _Copy(dev._root);
		}

		//赋值运算符重载
		BSTree<Key,Value>& operator=(BSTree<Key,Value> dev)
		{
			swap(_root, dev._root);
			return *this;
		}

		//节点查找
		Node* Find(const Key& key)
		{
			return _Find(_root, key);//体现了封装，简化用户使用，这里选择嵌套一层,这个最好函数被修饰为私有
		}

		//节点插入
		bool Insert(const Key& key,const Value&val)
		{
			return _Insert(_root, key, val);
		}

		//节点中序打印
		void PrintBSTree()
		{
			_PrintBSTree(_root);
			cout << endl;
		}

		bool Erase(const Key& key)
		{
			return _Erase(_root, key);
		}

		void Destory()
		{
			_Destory(_root);
		}
	private:
		Node* _root;



		bool _Erase(Node*& root, const Key& key);//声明

		Node* _Find(Node* root, const Key& key)
		{
			if (root == nullptr)
			{
				return nullptr;
			}

			if (root->_key > key)
			{
				_Find(root->_left, key);
			}
			else if (root->_key < key)
			{
				_Find(root->_right, key);
			}
			else
			{
				return root;
			}
		}

		bool _Insert(Node*& root, const Key& key, const Value& val)
		{
			if (root == nullptr)
			{
				root = new Node(key, val);//root是root->left别名相当于root->left=new BSTreeNode(key)
				return true;
			}

			if (root->_key > key)
			{
				_Insert(root->_left, key, val);
			}
			else if (root->_key < key)
			{
				_Insert(root->_right, key, val);
			}
			else//数字相同，不做处理
			{
				return false;
			}
		}

		void _PrintBSTree(Node* root)//中序遍历左子树->节点->右子树
		{
			if (root == nullptr)
				return;
			if (root->_left)
				_PrintBSTree(root->_left);
			cout << root->_key << ":" << root->_val << endl;
			if (root->_right)
				_PrintBSTree(root->_right);
		}

		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* CopNode = new Node(root->_key,root->_val);
			CopNode->_left = _Copy(root->_left);
			CopNode->_right = _Copy(root->_right);
			return CopNode;
		}
	};
}

template<class Key,class Value>
bool MyR_KeyValue::BSTree<Key,Value>::_Erase(Node*& root, const Key& key)
{
	if (root == nullptr)//没找到对应的位置
	{
		return false;
	}

	if (root->_key > key)
	{
		_Erase(root->_left, key);
	}
	else if (root->_key < key)
	{
		_Erase(root->_right, key);
	}
	else //找到要删除的位置
	{
		if (root->_left == nullptr)
		{
			Node* del = root;
			root = root->_right;//root是父节点的叶节点的引用相当于root->left=root->left->right;
			delete del;
		}
		else if (root->_right == nullptr)
		{
			Node* del = root;
			root = root->_left;
			delete del;
		}
		else //左右节点都不为空(替换法)
		{
			Node* minRight = root->_right;
			while (minRight->_left)
			{
				minRight = minRight->_left;
			}
			Key tmp = minRight->_key;//先保存右子树的最小值
			Value val = minRight->_val;
			_Erase(root->_right, tmp);//递归删除右子树的最小值
			root->_key = tmp;//将右子树的最小值赋给要删除节点
			root->_val = val;
			return true;
		}
	}
}

2.三叉链形式+动态插入动态删除过程_非递归

#include<iostream>
#include<ctime>
#include<cstdlib>
#include<vector>
#include<Windows.h>
using namespace std;

//三叉链,这里插入方式按照搜索二叉树key模型的插入规则来实现
template<class key>
struct BSTNode
{
	BSTNode* left;
	BSTNode* right;
	BSTNode* parent;
	key val;
	BSTNode(const key& _val) :left(nullptr), right(nullptr), parent(nullptr), val(_val) {}
};

template<class key>
class BSTree
{
public:
	typedef BSTNode<key> Node;

	BSTree() :Head(nullptr) {}

	~BSTree()
	{
		_Deleat(Head);
	}

	//拷贝构造函数
	BSTree(const BSTree<key>&dev)//前序构造
	{
		Head=_Copy(dev.Head);
	}

	//赋值运算符重载
	BSTree<key>& operator =(const BSTree<key>& dev)
	{
		BSTree<key>copy(dev);
		std::swap(Head, copy.Head);
		return *this;
	}

	//插入二叉树,不允许插入相同的值
	bool Insert(const key& _val)
	{
		if (Head == nullptr)
		{
			Head = new Node(_val);
			return true;
		}
		else
		{
			Node* tmp = Head;
			Node* Bef = nullptr;
			while (tmp != nullptr)
			{
				if (tmp->val > _val)
				{
					Bef = tmp;
					tmp = tmp->left;
				}
				else if (tmp->val < _val)
				{
					Bef = tmp;
					tmp = tmp->right;
				}
				else//找到相同的值
				{
					cout << "数字重复" << endl;
					return false;
				}
			}
			Node* cur = new Node(_val);
			cur->parent = Bef;
			if (Bef->val > _val)
			{
				Bef->left = cur;
			}
			else
			{
				Bef->right = cur;
			}
			return true;
		}
	}

	bool IsRightTree()//判断是否是搜索二叉树
	{
		return _IsRightTree(Head,GetMin(),GetMax());
	}

	//查找节点，返回节点指针
	Node* Find(const key& pos)
	{
		Node* find = Head;
		while (find != nullptr)
		{
			if (find->val > pos)
			{
				find = find->left;
			}
			else if (find->val < pos)
			{
				find = find->right;
			}
			else //找到了
			{
				return find;
			}
		}
		cout << "树中无此数字" << endl;
		return find;
	}

	//通过节点的数字删除节点
	bool DeleteNode(const key& val)
	{
		return _DeleatNode(Head, val);
	}

	//中序打印二叉树
	void PrintTree()
	{
		if (Head == nullptr)
		{
			cout<<"树为空"<<endl;
			return;
		}
		_PrintTree(Head);
		cout << endl;
	}
private:
	Node* Head;

	Node* _Copy(Node* cur)//拷贝构造函数,前序遍历
	{
		Node* NewHead = nullptr;
		if (cur != nullptr)
		{
			NewHead = new Node(cur->val);
			NewHead->left = _Copy(cur->left);
			NewHead->right = _Copy(cur->right);
		}
		return NewHead;
	}

	//树内置查找
	Node* _Find(Node* Tree, const key& val)
	{
		if (Tree == nullptr)
		{
			return nullptr;
		}
		Node* cur = Tree;
		while (cur!=nullptr)
		{
			if (cur->val > val)
			{
				cur = cur->left;
			}
			else if (cur->val < val)
			{
				cur = cur->right;
			}
			else
			{
				return cur;
			}
		}
		cout << "找不到节点" << endl;
		return nullptr;
	}

	const key GetMin()//获得树最小的数字
	{
		if (Head == nullptr)
		{
			cout << "树为空，不存在最小值" << endl;
			return 0;
		}
		else
		{
			Node* cur = Head;
			while (cur->left != nullptr)
			{
				cur = cur->left;
			}
			return cur->val;
		}
	}

	const key GetMax()//获得树最大的数字
	{
		if (Head == nullptr)
		{
			cout << "树为空，不存在最小值" << endl;
			return 0;
		}
		else
		{
			Node* cur = Head;
			while (cur->right != nullptr)
			{
				cur = cur->right;
			}
			return cur->val;
		}
	}

	//查每个节点能取的最大最小值是否满足
	bool _IsRightTree(Node* Head, const key& min, const key& max)
	{
		if (Head == nullptr || Head->val == 0)
		{
			return true;空节点也是二叉搜索树
		}
		else if (Head->val<min || Head->val>max)
		{
			return false;
		}
		return _IsRightTree(Head->left, min, Head->val - 1) && _IsRightTree(Head->right, Head->val + 1, max);
	}

	bool _DeleatNode(Node* Tree, const key& val)
	{
		Node* cur = _Find(Tree,val);
		if (cur == nullptr)
		{
			cout << "找不到数字，删除失败" << endl;
			return false;
		}
		//①要删除结点的左孩子为空或者右孩子为空
		if (cur->left == nullptr)//左孩子为空
		{
			//如果要删除的结点是根结点并且左孩子为空，替换根节点为右树根节点
			if (cur->parent == nullptr)
			{
				if (cur->right == nullptr)//一个节点
				{
					BSTree<int>tmp;
					std::swap(Head, tmp.Head);
					return true;
				}
				cur->right->parent = Head->parent;
				Head = cur->right;
				free(cur);
			}
			//不是根节点，则直接判断调整指向
			else
			{
				if (cur->right != nullptr)
				{
					cur->right->parent = cur->parent;//修改父节点
				}
				if (cur == cur->parent->left)
				{
					cur->parent->left = cur->right;
					free(cur);
				}
				else
				{
					cur->parent->right = cur->right;
					free(cur);
				}
			}
		}
		else if (cur->right == nullptr)
		{
			//如果要删除的结点是根结点并且右孩子为空，替换根节点为左树根节点
			if (cur->parent == nullptr)
			{
				if (cur->left == nullptr)
				{
					BSTree<int>tmp;
					std::swap(Head, tmp.Head);
					return true;
				}
				cur->left->parent = Head->parent;
				Head = cur->left;
				free(cur);
			}
			//不是根节点，则直接判断调整指向
			else
			{
				if (cur->left != nullptr)
				{
					cur->left->parent = cur->parent;
				}
				if (cur == cur->parent->left)
				{
					cur->parent->left = cur->left;
					free(cur);
				}
				else
				{
					cur->parent->right = cur->left;
					free(cur);
				}
			}
		}
		//②要删除结点的左右孩子都不为空(替换删除法)
		else
		{
			Node* repalce = cur->right;
			//找到要替换的结点(要删除结点右树最左边的那个结点就是替换结点)
			while (repalce->left)
			{
				repalce = repalce->left;
			}
			//替换数据
			cur->val = repalce->val;
			//删除这个节点和上面的逻辑重复了，可以递归实现删除右树的这个值
			_DeleatNode(cur->right, repalce->val);
		}
		return true;
	}

	void _Deleat(Node*Head)//后序
	{
		if (Head == nullptr)
		{
			return;
		}
		_Deleat(Head->left);
		_Deleat(Head->right);
		free(Head);
	}
	void _PrintTree(Node* _head)//中序
	{
		if (_head == nullptr)
			return;
		_PrintTree(_head->left);
		cout << _head->val << " ";
		_PrintTree(_head->right);
	}
};

//单元测试
void Test1()//测试二叉搜索树的插入，删除，判断，打印接口；
{
	BSTree<int>T;
	T.Insert(10);
	T.Insert(1);
	T.Insert(1);
	T.Insert(3);
	T.Insert(11);
	T.PrintTree();
	if (T.Find(11) != nullptr && T.Find(10000) == nullptr)
	{
		cout << "查找函数正确" << endl;
	}
	else
	{
		cout << "查找函数不正确" << endl;
	}
	if (T.IsRightTree())
	{
		cout << "是二叉搜索树" << endl;
	}
	else
	{
		cout << "插入错误，不是二叉搜索树" << endl;
	}
	T.DeleteNode(10);
	T.DeleteNode(3);
	T.DeleteNode(11);
}

void MoveDeleat()
{
	srand((unsigned int)time(0));
	BSTree<int>Tree;
	int Max = rand() % 10 + 10;//10到19大小的数组
	vector<int>tmp;
	for (int i = 0; i < Max; i++)
	{
		int Num = rand() % 10 + 10;
		cout << "开始插入数据" << endl;
		if (Tree.Insert(Num))
		{
			Tree.PrintTree();
			if (Tree.IsRightTree())
			{
				cout << "插入正确，是二叉搜索树" << endl;
			}
			Sleep(500);
			tmp.push_back(Num);
		}
	}
	Sleep(1000);
	cout << "删除开始" << endl << endl;;
	Sleep(500);
	for (int i = 0; i < tmp.size(); i++)
	{
		Tree.PrintTree();
		Tree.DeleteNode(tmp[i]);
		Sleep(500);
	}
	cout << "删除成功" << endl;
}

int main()
{
	BSTree<int>Tree;
	int input = 0;
	int Num = 0;
	int falg = 0;
	while (1)
	{
		if (falg == 1)
		{
			cout << "退出成功" << endl;
			break;
		}
		cout << "1.插入 2.删除 3.打印 4.查找 5.判断是否是二叉搜索树 6.退出 7.动态演示删除过程" << endl;
		cin >> input;
		switch (input)
		{
		case 1:
			system("cls");
			cout << "输入要插入的值" << endl;
			cin >> Num;
			Tree.Insert(Num);
			system("cls");
			break;
		case 2 :
			system("cls");
			Tree.PrintTree();
			cout << "要删除的值" << endl;
			cin >> Num;
			Tree.DeleteNode(Num);
			break;
		case 3:
			system("cls");
			cout << "树的中序遍历如下" << endl;
			Tree.PrintTree();
			break;
		case 4:
			cout << "要查找的值" << endl;
			cin >> Num;
			if (Tree.Find(Num))
			{
				cout << "找到了" << endl;
			}
			break;
		case 5:
			if (Tree.IsRightTree())
			{
				cout << "是二叉搜索树" << endl;
			}
			else
			{
				cout << "树结构错误" << endl;
			}
			break;
		case 6:
			falg = 1;
			break;
		case 7:
			cout << "随机数组动态删除如下" << endl;
			MoveDeleat();
			break;
		default:
			break;
		}
	}
	return 0;
}

运行结果

在这里插入图片描述

二叉搜索树删除节点思路

二叉搜索树的删除节点思路

上面的链接写的很清楚，不在赘述了

NUC_Dodamce
关注
专栏目录
【C++】二叉搜索树
knous
07-27 352
二叉搜索树及模拟实现，后续更新练习题
【进阶数据结构】二叉搜索树&经典习题讲解
最新发布
East-sunrise的博客
03-20 1008
二叉搜索树 —— 轻易找到你想要的
007 二叉搜索树的插入操作[C++]
热爱数据库的小胖
10-14 124
class Solution { public: TreeNode* insertIntoBST(TreeNode* root, int val) { //明确一个节点要做的事 if (root == nullptr) return new TreeNode(val); if (root->val == val) return root; //其他扔给递归循环 if (root-.
C/C++二叉树的删除递归法实现
疯狂的菜鸡
06-14 1129
时间: 2020-06-14 10:17 删除函数 (递归法) btree* Delete(btree* head, int key) { //传入根指针和要删除的节点的值 if (!head) { //根指针为空, (或待删除结点不存在) return NULL; } if (key < head->data) { //待删除节点的值小于目前节点的值 head->left = Delete(head->left, key); return head;
二叉排序树删除节点的递归替代法
weixin_43698578的博客
10-18 201
#include <iostream> using namespace std; //二叉查找树结点描述 typedef int KeyType; typedef struct Node { KeyType key; //关键字 - int struct Node * left; //左孩子指针 struct Node * right; //右孩子指针 //struct Node * parent; }Node, *PNode; //往二叉查找树中插
C++进阶 —— 二叉树搜索树
NapoleonCoder的博客
12-07 586
二叉搜索树，K、KV模型！
数据结构——二叉搜索树的删除操作
MDeleter的博客
02-18 1262
公有方法remove应该仅有一个参数(entry), 所以与调用私有递归方法addEntry的方法add一样，remove将调用一个私有递归方法removeEntry。 给removeEntry传递的是树根，而不是树本身。因为该方法可能从树中删除根节点，所以总要保留指向树根的引用。因此给removeEntry再传递外一个参数——oldEntry, 然后在该方法中用删除的项来改变它的值。 所以，removeEntry的头应该是 private BinaryNode<T> r...
二叉搜索树的基本操作
zjx624bjh的博客
03-19 251
概念：二叉搜索树又称为二叉排序树，它或者是一颗空树，或者是具有以下性质的二叉树 （1）若它的左子树不为空，则左子树上所有节点的值都小于根节点的值。 （2）若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。 （3）它的左右子树也分别为二叉搜索树。 下图就是一棵标准的搜索二叉树 构造一棵二叉搜索树的目的其实并不是为了排序而是为了提高查找和插入删除关键字的速度，在一个有序数据集上...
二叉搜索树的非递归实现
melody_1016的博客
01-17 567
“折半查找”这个词相信大家在学习C语言的时候已经很熟悉，由于数组中数字的排列是有序的，那么我们就可以将要查找的数字与最中间的数进行比较，每次比较都可以把范围缩小一半，依次下去，很好的提高了查找效率。而在数据结构中，我们也有处理这种问题的对应模型------二叉搜索树（也称为二叉排序树）。 二叉搜索树的性质： （1）每个节点都有一个作为搜索依据的关键码（key）,所有节点的关键码互不相同 （2
二叉树--二叉搜索树
Hy_2267的博客
04-11 693
编号2的二叉树中，叶子节点全都在最底层，除了叶子节点之外，每个节点都有左右两个子节点，这种二叉树就叫做满二叉树。 叶子节点都在最底下两层，最后一层的叶子节点都靠左排列，并且除了最后一层，其他层的节点个数都要达到最大，这种二叉树叫做完全二叉树。 如何表示（或者存储）一棵二叉树？ 链式存储法：一种是基于指针或者引用的二叉链式存储法 基于数组的顺序存储法：一种是基于数组的顺序存储法 把根节点存储在下标i = 1的位置，那左子节点存储在下标2 * i = 2的位置，右子节点存储在2 * i + 1..
C++实现二叉树的插入、删除、查询、遍历
热门推荐
远走的兔子博客
04-09 4万+
1.二叉树的概念        树是一些节点的集合，节点之间用边链接，节点之间不能有环路。上层的节点称为父节点，下层节点称为子节点。最上层的节点称为根节点。       二叉树是特殊的树。对于每个节点而言，与之直接相连的子节点不能超过两个（可以为0）。左边的子节点称为左子树，右边的子节点称为右子树。如下图就是一颗二叉树： 与树相关的一些概念：          没有任何子节点的节点
C++二叉排序树的创建、插入、删除
叶子的小本本
01-04 1575
二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。 一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树； （4）没有键值相等的结点。 Code #include<iostream> #include<string> #include<algorithm&g
C++实现二叉搜索树的插入、搜索、删除
cyaaws的博客
08-31 1148
//二叉树的插入 //迭代 TreeNode* insertIntoBST(TreeNode* root, int val) { if (!root) { TreeNode node = new TreeNode(val); return node; } else { TreeNode p = root; while (true) { if (p->val > val)//左子树 { ...
C++ 二叉查找树 —— 插入、遍历、查找、删除、销毁
辛旭东小小工作室
03-15 2457
二叉查找树的特性： 二叉查找树（Binary Search Tree）（又：二叉搜索树，二叉排序树） 具有以下特性： （1）若“左子树”不为空，则“左子树”上所有节点的值均小于“根节点”的值； （2）若“右子树”不为空，则“右子树”上所有节点的值均大于“根节点”的值； （3）左、右子树也分别为二叉排序树。 01 声明： #include &lt;iostream&gt; us...
二叉搜索树（BST）
nameofcsdn的博客
03-02 4241
目录 一，二叉搜索树（二叉查找树，二叉排序树） 二，OJ实战 力扣98. 验证二叉搜索树 力扣 96. 不同的二叉搜索树 力扣 95. 不同的二叉搜索树 II 一，二叉搜索树（二叉查找树，二叉排序树） 二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。 二，OJ实战 力扣98. 验证二叉搜索树 题目： 给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树...
C++：二叉树查找的实现（一）——插入操作
Serve it
11-16 3247
    二叉查找树，又称二叉排序树，是具有下列性质的二叉树：     （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；    （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；    （3）左、右子树也分别为二叉排序树；     （4）没有键值相等的节点。    图1就是一个典型的二叉查找树：          对二叉查找树的操作包括建立、插入、查找、遍...
[C++]---二叉搜索树简单实现(查找，插入，删除)
夜微雨的博客
02-28 1422
目录 二叉搜索树概念及特点 1.特点 二叉搜索树的简单操作 1.查找操作 2.插入操作 3.删除操作 二叉搜索树的性能分析 二叉搜索树概念及特点 1.特点 二叉搜索树又称二叉排序树，它可能是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别...
二叉搜索树的插入,查找,删除和遍历(c/c++)
weixin_42480264的博客
08-19 2268
二叉搜索树的建立 二叉搜索树的建立即为向二叉树中插入元素.开始插入第一个元素时,二叉搜索树是空树,直接申请一个内存空间将元素放入树中.再插入元素时,从根节点开始比较,若待插入的元素值较大,则树中节点向右走,若较小,则树中节点向左走,直到找到一个空位置,将节点插入. 二叉搜索树中查找元素 在二叉搜索树中查找元素时,先将元素与根节点值比较,若元素的值较小,则根节点向左走(root = root-...
详解二叉搜索树的查找、插入、删除操作（数据结构）
m0_51405559的博客
11-26 2173
文章目录一、概念二、操作——查找三、操作——插入四、操作——删除（难点） 一、概念 二叉搜索树又称二叉排序树，它可能是一棵空树，也可能是具有以下性质的二叉树： 1.若它的左子树不为空，则左子树上所有结点的值都小于根结点的值 2.若他的右子树不为空，则右子树上所有结点的值都大于根结点的值 3.它的左右子树也分别为二叉搜索树 例如下图： 二、操作——查找 步骤： 1.假如根结点不为空： 如果根结点.key==查找.key，返回true 如果根结点.key>查找.key，在其左子树中查找 ..
二叉搜索树的基本操作：插入、查找与删除
这些基本操作构成了二叉搜索树的主要功能，使得我们可以高效地在树中插入、查找和删除数据。在实际应用中，二叉搜索树广泛应用于数据库索引、编译器符号表、文件系统等场景。理解并熟练掌握这些操作对于深入学习数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

NUC_Dodamce

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

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

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

打赏作者

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

抵扣说明：

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

余额充值