二叉搜索树（C语言实现）

最新推荐文章于 2022-02-27 15:05:58 发布
最新推荐文章于 2022-02-27 15:05:58 发布
阅读量571 收藏 6
点赞数 1
分类专栏： 数据结构与算法 文章标签： 二叉树 递归算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46272577/article/details/116265851
版权
这段代码实现了一个二叉搜索树（BST），包括插入元素、删除元素、查找最小和最大元素、按值查找以及中序遍历的功能。删除操作考虑了叶节点、单支节点和双支节点三种情况。此外，提供了菜单驱动的用户交互界面，方便进行各种操作。
摘要由CSDN通过智能技术生成

数据结构

typedef struct TreeNode {
	int data;//数据 
	struct TreeNode* left;//左孩子 
	struct TreeNode* right;//右孩子 
}BST, *BinTree;

 函数声明

void Insert(BinTree& BST, int x);//插入元素 
void Delete(BinTree& BST, int x);//删除元素 
BinTree FindMin(BinTree BST);//找寻最小值
BinTree FindMax(BinTree BST);//找寻最大值
BinTree FindElem(BinTree BST, int x);//按值查找
void MidOrder(BinTree BST);//中序遍历

void Insert_menu(BinTree& BST);
void Delete_menu(BinTree& BST);
void FindMin_menu(BinTree BST);
void FindMax_menu(BinTree BST);
void FindElem_menu(BinTree BST);
void MidOrder_menu(BinTree BST);

 插入元素

//插入元素 
void Insert(BinTree& BST, int x) {
	if (BST == NULL) {
		BST = (BinTree)malloc(sizeof(struct TreeNode));//构建结点 
		BST->data = x;
		BST->left = NULL;
		BST->right = NULL;
		return;
	}
	else if (x > BST->data) {//去右边找 
		Insert(BST->right, x);
	}

	else if (x < BST->data) {//去左边找 
		Insert(BST->left, x);
	}
}

删除元素（情况很多，代码有注释）

叶节点情况

  • 删除节点为根节点：直接删除，指向根节点的指针指向空，释放节点
  • 删除节点为非根节点：其父节点哪边有儿子，哪边指向空，释放节点
	if (node_temp->left == NULL && node_temp->right == NULL) {
		//若为根节点 
		if (node_temp == BST) {
			BST = NULL;//直接让根节点为空 
		}
		//非跟节点 
		else if (node_par->left == node_temp) { //若为左儿子 
			node_par->left = NULL;//让其父亲节点的左边为空 
		}
		else { //若为右儿子 
			node_par->right = NULL;//让其父亲节点的右边为空 
		}
	}

单支节点情况

  • 删除节点为根节点：哪边有儿子，指向根节点的指针就指向有儿子的那一边，释放节点
  • 删除节点为非根节点：判断被删除节点是父节点的哪一边儿子，判断被删除节点拥有哪一边儿子
if (node_par->left == node_temp && temp->left != NULL) { 
				node_par->left = node_temp->left;//父亲指针绕过其左儿子直接指向其左儿子的左儿子 
			}
			if (node_par->left == node_temp && temp->right != NULL) {
				node_par->left = node_temp->right;//父亲指针直接绕过其左儿子，指向其左儿子的有儿子 
			}
			if (node_par->right == node_temp && temp->left != NULL) {
				node_par->right = node_temp->left;//父亲指针直接绕过其右儿子，指向其右儿子的左儿子 
			}
			if (node_par->right == node_temp && temp->right != NULL) {
				node_par->right = node_temp->right;//父亲指针直接绕过其右儿子，指向其右儿子的右儿子 
			}

 

双支节点情况

  • 临时变量记录此刻找到的节点
  • 去该节点右子树，找到最小的节点，记得记录最小节点的父节点
  • 值覆盖
  • 删除右子树的最小节点
    • 右子树有左儿子
    • 右子树无左儿子
else if (node_temp->left != NULL && node_temp->right != NULL) {
		BinTree temp = node_temp;
		node_temp = node_temp->right; 
		//找寻右子树的最小值 
		while (node_temp->right) {
			node_par = node_temp;//记录找到最小结点的父节点 
			node_temp = node_temp->left;
		}
		temp->data = node_temp->data;//数据覆盖
		//node_temp->right 因为找右子树的最小值，所以一定在最左边，且无左儿子，否则还可以找到更小的 
		if (node_par == temp) { //右子树只有一个元素 
			node_par = node_temp->right;
		} 
		else {
			node_par->left = node_temp->right;
		}
	}

void Delete(BinTree& BST, int x)
{
	if (BST == NULL) return;
	BinTree node_temp = BST;
	BinTree node_par = NULL;//记录被删除结点的父亲节点 
	BinTree temp = NULL;
	
	while (node_temp->data != x)
	{
		if (x > node_temp->data) {
			node_par = node_temp;
			node_temp = node_temp->right;
		}

		else if (x < node_temp->data) {
			node_par = node_temp;
			node_temp = node_temp->left;
		}
			
	}
	
	//无此值 退出 
	if (node_temp == NULL) return;
	
	//叶节点
	if (node_temp->left == NULL && node_temp->right == NULL) {
		//若为根节点 
		if (node_temp == BST) {
			BST = NULL;//直接让根节点为空 
		}
		//非跟节点 
		else if (node_par->left == node_temp) { //若为左儿子 
			node_par->left = NULL;//让其父亲节点的左边为空 
		}
		else { //若为右儿子 
			node_par->right = NULL;//让其父亲节点的右边为空 
		}
	} 
	
	//单支节点 
	else if (node_temp->left != NULL || node_temp->right != NULL) {
		//若为根节点 
		if (node_temp == BST) {
			if (node_temp->left != NULL) { //若有左儿子,原本指向根节点的指针指向其左儿子即可 
				BST = node_temp->left;
			}
			else { //若有右儿子 
				BST = node_temp->right; //若有右儿子,原本指向根节点的指针指向其右儿子即可
			}
		}
		//非根结点 
		else { //将其儿子给父亲 
			if (node_par->left == node_temp && temp->left != NULL) { 
				node_par->left = node_temp->left;//父亲指针绕过其左儿子直接指向其左儿子的左儿子 
			}
			if (node_par->left == node_temp && temp->right != NULL) {
				node_par->left = node_temp->right;//父亲指针直接绕过其左儿子，指向其左儿子的有儿子 
			}
			if (node_par->right == node_temp && temp->left != NULL) {
				node_par->right = node_temp->left;//父亲指针直接绕过其右儿子，指向其右儿子的左儿子 
			}
			if (node_par->right == node_temp && temp->right != NULL) {
				node_par->right = node_temp->right;//父亲指针直接绕过其右儿子，指向其右儿子的右儿子 
			}
		}
	}
	//双支节点 
	else if (node_temp->left != NULL && node_temp->right != NULL) {
		BinTree temp = node_temp;
		node_temp = node_temp->right; 
		//找寻右子树的最小值 
		while (node_temp->right) {
			node_par = node_temp;//记录找到最小结点的父节点 
			node_temp = node_temp->left;
		}
		temp->data = node_temp->data;//数据覆盖
		//node_temp->right 因为找右子树的最小值，所以一定在最左边，且无左儿子，否则还可以找到更小的 
		if (node_par == temp) { //右子树只有一个元素 
			node_par = node_temp->right;
		} 
		else {
			node_par->left = node_temp->right;
		}
	}
	
	free(node_temp);//释放节点 
}

返回最小元素的结点

BinTree FindMin(BinTree BST) {
	if (BST == NULL)
		return NULL;
	while (BST->left != NULL) {
		BST = BST->left;
	}
	return BST;
}

 返回最大元素的结点

BinTree FindMax(BinTree BST) {
	if (BST == NULL)
		return NULL;
	while (BST->right != NULL) {
		BST = BST->right;
	}
	return BST;
}

 按值查找

//按值查找 
BinTree FindElem(BinTree BST, int x) {
	if (BST == NULL) {
		return NULL;
	}
	else if (x > BST->data) {
		BST = FindElem(BST->right,x);
	}
	else if (x < BST->data) {
		BST = FindElem(BST->left, x);
	}
	return BST;
}

中序遍历

void MidOrder(BinTree BST) {
	if (BST != NULL) {
		MidOrder(BST->left);
		printf("%d", BST->data);
		MidOrder(BST->right);
	}
}

 

 源代码

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstdlib>
using namespace std;

typedef struct TreeNode {
	int data;//数据 
	struct TreeNode* left;//左孩子 
	struct TreeNode* right;//右孩子 
}BST, *BinTree;

void Insert(BinTree& BST, int x);//插入元素 
void Delete(BinTree& BST, int x);//删除元素 
BinTree FindMin(BinTree BST);
BinTree FindMax(BinTree BST);
BinTree FindElem(BinTree BST, int x);
void MidOrder(BinTree BST);

void Insert_menu(BinTree& BST);
void Delete_menu(BinTree& BST);
void FindMin_menu(BinTree BST);
void FindMax_menu(BinTree BST);
void FindElem_menu(BinTree BST);
void MidOrder_menu(BinTree BST);

void menu();

int main() {
	BinTree BST = NULL;//记得初始化为空指针，否则报错
	int max, min;
	int choice;
	while (true)
	{
		menu();
		scanf("%d", &choice);
		switch (choice)
		{
		case 0:
			exit(1);
			break;
		case 1:
			Insert_menu(BST);
			break;
		case 2:
			Delete_menu(BST); 
			break;
		case 3:
			MidOrder_menu(BST);
			printf("\n");
			break;
		case 4:
			FindElem_menu(BST);
			break;
		case 5:
			FindMax_menu(BST);
			break;
		case 6:
			FindMin_menu(BST);
			break;
		}
	}
	
	for (int i = 1; i <= 5; i++) {
		Insert(BST, i);
	}
	MidOrder(BST);
	cout << endl;
	BinTree temp;
	temp = FindMax(BST);
	cout << "Max = " << temp->data << endl;
	temp = FindMin(BST);
	cout << "Min = " << temp->data << endl;
	Delete(BST, 2);
	if (BST != NULL)
	MidOrder(BST);
	return 0;
}

void menu()
{
	printf("------------0.退出程序------------\n");
	printf("------------1.插入元素------------\n");
	printf("------------2.删除元素------------\n");
	printf("------------3.中序遍历------------\n");
	printf("------------4.查找元素------------\n");
	printf("------------5.最大元素------------\n");
	printf("------------6.最小元素------------\n");
}

//插入元素 
void Insert(BinTree& BST, int x) {
	if (BST == NULL) {
		BST = (BinTree)malloc(sizeof(struct TreeNode));//构建结点 
		BST->data = x;
		BST->left = NULL;
		BST->right = NULL;
		return;
	}
	else if (x > BST->data) {//去右边找 
		Insert(BST->right, x);
	}

	else if (x < BST->data) {//去左边找 
		Insert(BST->left, x);
	}
}

//删除元素 
void Delete(BinTree& BST, int x)
{
	if (BST == NULL) return;
	BinTree node_temp = BST;
	BinTree node_par = NULL;//记录被删除结点的父亲节点 
	BinTree temp = NULL;
	
	while (node_temp->data != x)
	{
		if (x > node_temp->data) {
			node_par = node_temp;
			node_temp = node_temp->right;
		}

		else if (x < node_temp->data) {
			node_par = node_temp;
			node_temp = node_temp->left;
		}
			
	}
	
	//无此值 退出 
	if (node_temp == NULL) return;
	
	//叶节点
	if (node_temp->left == NULL && node_temp->right == NULL) {
		//若为根节点 
		if (node_temp == BST) {
			BST = NULL;//直接让根节点为空 
		}
		//非跟节点 
		else if (node_par->left == node_temp) { //若为左儿子 
			node_par->left = NULL;//让其父亲节点的左边为空 
		}
		else { //若为右儿子 
			node_par->right = NULL;//让其父亲节点的右边为空 
		}
	} 
	
	//单支节点 
	else if (node_temp->left != NULL || node_temp->right != NULL) {
		//若为根节点 
		if (node_temp == BST) {
			if (node_temp->left != NULL) { //若有左儿子,原本指向根节点的指针指向其左儿子即可 
				BST = node_temp->left;
			}
			else { //若有右儿子 
				BST = node_temp->right; //若有右儿子,原本指向根节点的指针指向其右儿子即可
			}
		}
		//非根结点 
		else { //将其儿子给父亲 
			if (node_par->left == node_temp && temp->left != NULL) { 
				node_par->left = node_temp->left;//父亲指针绕过其左儿子直接指向其左儿子的左儿子 
			}
			if (node_par->left == node_temp && temp->right != NULL) {
				node_par->left = node_temp->right;//父亲指针直接绕过其左儿子，指向其左儿子的有儿子 
			}
			if (node_par->right == node_temp && temp->left != NULL) {
				node_par->right = node_temp->left;//父亲指针直接绕过其右儿子，指向其右儿子的左儿子 
			}
			if (node_par->right == node_temp && temp->right != NULL) {
				node_par->right = node_temp->right;//父亲指针直接绕过其右儿子，指向其右儿子的右儿子 
			}
		}
	}
	//双支节点 
	else if (node_temp->left != NULL && node_temp->right != NULL) {
		BinTree temp = node_temp;
		node_temp = node_temp->right; 
		//找寻右子树的最小值 
		while (node_temp->right) {
			node_par = node_temp;//记录找到最小结点的父节点 
			node_temp = node_temp->left;
		}
		temp->data = node_temp->data;//数据覆盖
		//node_temp->right 因为找右子树的最小值，所以一定在最左边，且无左儿子，否则还可以找到更小的 
		if (node_par == temp) { //右子树只有一个元素 
			node_par = node_temp->right;
		} 
		else {
			node_par->left = node_temp->right;
		}
	}
	
	free(node_temp);//释放节点 
}

//最小元素 
BinTree FindMin(BinTree BST) {
	if (BST == NULL)
		return NULL;
	while (BST->left != NULL) {
		BST = BST->left;
	}
	return BST;
}

//最大元素 
BinTree FindMax(BinTree BST) {
	if (BST == NULL)
		return NULL;
	while (BST->right != NULL) {
		BST = BST->right;
	}
	return BST;
}

//按值查找 
BinTree FindElem(BinTree BST, int x) {
	if (BST == NULL) {
		return NULL;
	}
	else if (x > BST->data) {
		BST = FindElem(BST->right,x);
	}
	else if (x < BST->data) {
		BST = FindElem(BST->left, x);
	}
	return BST;
}

//中序遍历 
void MidOrder(BinTree BST) {
	if (BST != NULL) {
		MidOrder(BST->left);
		printf("%d", BST->data);
		MidOrder(BST->right);
	}
}

//---------------------------------------
void Insert_menu(BinTree& BST)
{
	int n, x;
	printf("请输入您想要插入的元素个数\n");
	scanf("%d", &n);
	printf("请输入元素\n");
	for (int i = 0; i < n; i++)
	{
		scanf("%d", &x);
		Insert(BST, x);
	}
	printf("插入成功\n");
	system("pause");
	system("cls");
} 

void Delete_menu(BinTree& BST)
{
	printf("请输入您想删除的元素\n");
	int x; 
	scanf("%d", &x);
	Delete(BST,x);
	printf("删除成功\n");
	system("pause");
	system("cls");
}

void FindMin_menu(BinTree BST)
{
	BinTree temp = FindMin(BST);
	if (temp == NULL) 
	printf("树为空\n");
	else {
		printf("最小值为：%d", temp->data);
	}	
	system("pause");
	system("cls");
}

void FindMax_menu(BinTree BST)
{
	BinTree temp = FindMax(BST);
	if (temp == NULL) 
	printf("树为空\n");
	else {
		printf("最大值为：%d", temp->data);
	}
	system("pause");
	system("cls");
}

void FindElem_menu(BinTree BST)
{
	int x;
	printf("请输入您想要查询的值\n");
	scanf("%d", &x);
	BinTree temp = FindElem(BST,x);
	if (temp == NULL) 
	printf("无此值存在\n");
	else {
		printf("该值存在\n"); 
	}
	system("pause");
	system("cls");
}

void MidOrder_menu(BinTree BST) {
	MidOrder(BST);
	system("pause");
	system("cls");
}

运行结果

Last-Week
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言实现二叉搜索树
03-23
1.实现二叉搜索树的基本操作 2.包括建立，查找，删除，显示 3.得到最长路径和最短路径，并能分别计算长度
二叉排序树的C语言实现
09-15
二叉排序树，又称二叉查找树或二叉搜索树，是一种特殊的二叉树数据结构，它具有以下特性：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种性质使得...
【二叉搜索树】的详细实现(C++)
dielu7895的博客
05-20 366
二叉搜索树的概念 　　从前面讨论折半搜索的性能中可知，如果每次从搜索序列的中间进行搜索，把区间缩小一半，通过有限次迭代，很快就能通近到所要寻找的元素。进一步，如果我们直接输入搜索序列，构造出类似于折半搜索的判定树那样的树形结构，就能实现快速搜索。这种树形结构就是二又搜索树。 二又搜索树（binary search tree）或者是一棵空树，或者是具有下列性质的二又树： 　　（1）每...
【二叉树】--C语言实现创建二叉搜索树
学益得的博客
03-16 722
二叉搜索树 创建二叉搜索树的过程很简单，第一个数字作为根，第二个数字，如果比根大，则作为根的右子树，如果比根小，则作为根的左子树。一次类推。对一棵二叉搜索树进行中序遍历，可以的到一个有序的序列。 代码 #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node *le...
二叉搜索树 c语言,二叉搜索树（C语言实现）
weixin_39823459的博客
05-23 319
数据结构typedef struct TreeNode {int data;//数据struct TreeNode* left;//左孩子struct TreeNode* right;//右孩子}BST, *BinTree;函数声明void Insert(BinTree& BST, int x);//插入元素void Delete(BinTree& BST, int x);//删除...
二叉搜索树操作
_计算机好苦
10-11 159
/* 你的代码将被嵌在这里 */ BinTree Insert(BinTree BST, ElementType X) { if (BST == NULL) { BST = (BinTree)malloc(sizeof(struct TNode)); BST->Data = X; BST->Left = NULL; BST->Right = NULL; } else if (X < BST->Data) BST->Left = Insert.
050 二叉搜索树操作 C语言
06-01
在C语言中实现二叉搜索树，我们需要定义一个结构体来表示节点，通常包括键值、左右子节点的指针以及可能需要的其他信息。以下是一个简单的节点定义： ```c typedef struct Node { int key; struct Node* left; ...
C语言实现二叉搜索树，可插入、删除搜索节点
最新发布
06-27
C语言实现二叉搜索树，可插入、删除搜索节点，代码量只有100多行，注释详实，对萌新十分友好 博客地址：https://tinycool.blog.csdn.net/article/details/131423285
二叉搜索树_二叉搜索树_源码
10-04
源代码文件很可能是用C语言编写的，用于演示如何实现二叉搜索树的基本操作。C语言是一种底层、高效的编程语言，常用于实现数据结构和算法。 在二叉搜索树的实现中，通常会包含以下关键函数： 1. **创建节点**：`...
数据结构 --- c语言二叉搜索树(有序的树)
weixin_60569662的博客
02-27 2621
二叉搜索树基础 左边孩子节点的值 < 父节点的值，右边孩子节点的值 > 父节点的值 每个二叉搜索树的子树也是一棵二叉搜索树 10 充当根节点 18 > 根节点，放在根节点右边；3 < 根节点，放在根节点左边；8 首先与根节点相比较，8 < 根节点，所以应该放在根节点的左边；然后 8 与 3 比较，3 < 8，8 应该放在 3 的右边，持续构建即可 二叉搜索树的特性：中序遍历是一个有序序列，从小到大排序，2-3-4-7-.
c语言实现的用动态规划实现最优二叉查找树
06-13
c语言实现的用动态规划实现最优二叉查找树，，，具体参见附件，2.txt中的内容为： 5 0.15 0.10 0.05 0.10 0.20
最优二叉搜索树
06-26
最优二叉搜索树，计算机算法设计与分析的一个题目
c语言动态规划最优二叉搜索树,最优二叉搜索树（动态规划）
weixin_35666711的博客
05-25 1000
#include#include#include#include#includeenum:int{MAXVALUE=999};templateclassBestTree{private:T**root;//记录给定子树的根节点.Ty**e;//记录子树概率总和.Type**w;//记录子树代价总和.std::vectorp;std::vectorq;intpLengt...
二叉搜索树 c 语言实现
Daniel 的技术笔记 不积跬步无以至千里，不积小流无以成江海。
08-06 3704
一、介绍 二叉搜索树（Binary Search Tree），或者是一棵空树，或者是具有下列性质的二叉树： 1，若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 2，若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 3，它的左、右子树也分别为二叉搜索树。 二叉搜索树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉搜索序树的存储结构。中序遍历二叉搜索树可得到
用c语言打二叉搜索树的建立,建立二叉搜索树c语言
weixin_32321921的博客
05-23 498
广告精选中小企业最主流配置，适用于web应用场景、小程序及简单移动App，所有机型免费分配公网IP和50G高性能云硬盘(系统盘)。你可以在网上找到关于二叉搜索树非常好的文章，我们不会提供二叉搜索树的完整实现，但为了维持一致性，我们而是会举例表明一个简单的二叉搜索树...相比之下，建立一个节点具有多个顺序索引(key)的平衡二叉搜索树(balanced binary search tree)可能会更...
动态规划最优二叉搜索树C语言,算法 – 动态规划：最优二叉搜索树
weixin_42303112的博客
05-23 1057
好吧,我希望有人可以向我解释一下.我正在攻读决赛,我无法解决问题.问题是动态编程;构造最优二叉搜索树(OBST).我理解一般的动态编程和特别是这个问题的概念,但我不明白这个问题的递归形式.我得到的是,我们正在为这些节点中不断增加的子集构建最优二叉搜索树,并在我们继续时将答案保存在表中以避免重新计算.当你在a_ {k}根树时,我也得到了这一点,所有来自a_ {1}到a_ {k-1}的成功节点以及它们...
二叉查找树 c
he626shidizai的博客
05-23 335
目录 递归定义 头文件 实现文件 1. 结构体定义 2. 查找函数 3. 查找关键值最小的结点 4. 查找关键值最大的结点 5. 插入函数 6. 删除函数 7. 其他函数(MakeEmpty,Retrive) 二叉查找树的递归定义 二叉查找树（Binary Search Tree, BST),在不同的书上我发现也可以叫二叉搜索树，二叉排序树。 二叉树的一个重要应用就是在查找中的应用，现在我们...
二叉搜索树 C语言实现
weixin_34128411的博客
12-04 104
1、二叉搜索树基本概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是一棵具有如下特性的非空二叉树： （1）若它的左子树非空，则左子树上所有结点的关键字均小于根结点的关键字； （2）若它的右子树非空，则右子树上所有结点的关键字均大于（允许的话，也可大于等于）根结点的关键字； （3）左右子树本身又各是一个二叉搜索树。 根据二叉搜索树的特点知：对二叉搜索树进行中序遍历得到的结点序列必然是...
动态规划最优二叉搜索树C语言,【算法导论】动态规划之“最优二叉搜索树”...
weixin_42505032的博客
05-23 1222
详解动态规划之“最优二叉搜索树”之前两篇分别讲了动态规划的“钢管切割”和“矩阵链乘法”，感觉到了这一篇，也可以算是收官之作了。其实根据前两篇，到这里，也可以进行一些总结的，我们可以找到一些规律性的东西。所谓动态规划，其实就是解决递归调用中，可能出现重复计算子问题，从而导致耗费大量时间，去做重复劳动的问题。解决思路就是，将重复做过的子问题的结果，先存起来，等之后再需要用到的时候，直接拿过来用，而不需...
二叉搜索树的构建与应用 实践通过插入操作创建二叉搜索树 c语言实现
05-27
好的，我可以为您提供有关二叉搜索树的构建与应用的一些基本知识，并提供一个基于C语言的插入操作来创建二叉搜索树的示例代码。 二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树，它的每个节点最多有两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值