B-树总结

最新推荐文章于 2024-04-14 01:09:25 发布
原创 最新推荐文章于 2024-04-14 01:09:25 发布 · 490 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了B-树的定义与特性，详细解析了其数据结构与算法实现，包括初始化、查找、插入等核心操作，适用于多路查找场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

前天和昨天一直在写实验六的题目二，想挑战一下自己，所以选择用B-树的数据结构，这篇是一篇关于B-树的总结。
B-树是一种平衡的多路查找树。
一棵m阶的B-树，或者为空树，或为满足下列特征的m叉树：

  1. 树中每个结点至多有m棵子树；

  2. 若根结点不是叶子结点，则至少有两棵子树；

  3. 除根之外的所有非终端结点至少有m/2（向上取)棵子树；

  4. 所有的非终端结点中包含下列信息数据
    （n，A0，K1，A1，K2，A2,…，Kn，An）、
    其中：Ki（i=1,…,n)为关键字，且Ki<K(i+1)(i=1,…,n-1);Ai(i=0,…,n)为指向子树根结点的指针，且指针A(i-1)所指的子树中所有结点的关键字均小于Ki（i=1，…,n),An所指子树中所有结点的关键字均大于Kn，n（m/2（向上取）-1<=n<=m-1)为关键字的个数（或n+1为子树个数）。

  5. 所有的叶子结点都出现在同一层次上，并且不带信息（可以看作是外部结点或查找失败的结点，实际上这些结点不存在，指向这些结点的指针为空）

B-树的结构体

#define m 3
typedef struct BTNode     //B-树的阶，暂设为3
{
   int keynum;                  //结点中关键字个数，即结点的大小
   struct BTNode *parent;       //指向双亲结点
   KeyType key[m+1];            //关键字向量，0号单元未用
   struct BTNode *ptr[m+1];     //子树指针向量
   Record *recptr[m+1];         //记录指针向量，0号单元未用
}BTNode,*BTree;                 //B-树结点和B-树的类型

typedef struct 
{
  BTNode *pt;      //指向找到的结点
  int i;           //1，....,m，在结点中的关键字序号
  int tag;         //1：查找成功，0:查找失败
}Result;           //B-树的查找结果类型

具体实现算法

Status InitBTree(BTree &t)   //生成一个新B-树
{
	t = NULL;
	return OK;
}
int SearchBTNode(BTNode *p, KeyType k)  //在结点中寻找关键字的位置
{
	int i = 0;
	while (i < p->keynum&&strcmp(p->key[i + 1], k) <= 0)
	{
		i++;
	}
	return i;
}
Result SearchBTree(BTree t, KeyType k)
{
	BTNode *p = t, *q = NULL;      //初始化结点p和结点q，p指向待查结点，q指向p的双亲
	int found_tag = 0;              //设定查找成功与否标志
	int i = 0; 
	Result r;                     //设定返回的查找结果
	while (p != NULL && found_tag == 0)
	{
		i = SearchBTNode(p, k);                //在结点p中查找关键字k
		if (i > 0 && strcmp(p->key[i], k) == 0)      //查找成功
		{
			found_tag = 1;
		}
		else               //查找失败
		{
			q = p;
			p = p->ptr[i];
		}
	}
	if (found_tag == 1)           //查找成功
	{
		r.pt = p;
		r.i = i;
		r.tag = 1;
	}
	else                  //查找失败
	{ 
		r.pt = q;
		r.i = i;
		r.tag = 0;
	}
	return r;                //返回关键字k的位置（或者插入位置）
} 

void InsertBTNode(BTNode *&p, int i, KeyType k, BTNode *q,int a)  //将p->key[s+1,...,m]，p->ptr[s+1,...,m]和p->recptr[s+1,...,m]移入新节点q
{
	int j;
	for (j = p->keynum;j > i;j--)          //整体后移空出一个位置
	{
		strcpy(p->key[j + 1], p->key[j]);
		p->recptr[j + 1] = p->recptr[j];
		p->ptr[j + 1] = p->ptr[j];
	}
	strcpy(p->key[i + 1], k);
	p->recptr[i + 1] = a;
	p->ptr[i + 1] = q;
	if (q != NULL)
		q->parent = p;
	p->keynum++;
}

void SplitBTNode(BTNode*&p, BTNode *&q)  //将p->key[s+1,...,m]，p->ptr[s+1,...,m]和p->recptr[s+1,...,m]移入新节点q
{
	int i;
	int s = (m + 1) / 2;
	q = (BTNode *)malloc(sizeof(BTNode));    //给结点q分配空间
	q->ptr[0] = p->ptr[s];
	for (i = s + 1;i <= m;i++)       //后一半移入结点q
	{
		strcpy(q->key[i - s], p->key[i]);
		q->recptr[i - s] = p->recptr[i];
		q->ptr[i - s] = p->ptr[i];
	}
	q->keynum = p->keynum - s;
	q->parent = p->parent;
	for (i = 0;i <= p->keynum - s;i++)     //修改双亲指针
	{
		if (q->ptr[i] != NULL)
			q->ptr[i]->parent = q;
	}
	p->keynum = s - 1;               //结点p的前一半保留，修改结点p的keynum
}

void NewRoot(BTNode *&t, KeyType k, BTNode *p, BTNode *q,int a)
{
	t = (BTNode *)malloc(sizeof(BTNode));    //分配空间
	t->keynum = 1;
	t->ptr[0] = p;
	t->ptr[1] = q;
	strcpy(t->key[1], k);
	t->recptr[1] = a;
	if (p != NULL)             //调整结点p和q的双亲指针
		p->parent = t;
	if (q != NULL)
		q->parent = t;
	t->parent = NULL;
}

void InsertBTree(BTree &t, int i, KeyType k, BTNode *p,int a)
{
	BTNode *q; 
	int b;
	int finish_tag, newroot_tag, s;          //设定需要新结点标志和插入完成标志
	KeyType x;
	if (p == NULL)           //t是空树
		NewRoot(t, k, NULL, NULL,a);             //生成仅含关键字k的根结点t
	else
	{
		strcpy(x,k);
		b = a;
		q = NULL;
		finish_tag = 0;
		newroot_tag = 0;
		while (finish_tag == 0 && newroot_tag == 0)
		{
			InsertBTNode(p, i, x, q,b);  //将关键字x和结点q分别插入到p->key[i+1]和p->[i+1]
			if (p->keynum <= Max)        //插入完成
				finish_tag = 1;
			else
			{
				s = (m + 1) / 2;
				SplitBTNode(p, q);         //分裂结点
				strcpy(x, p->key[s]);
				b = p->recptr[s];
				if (p->parent)         //查找x 的插入位置
				{ 
					p = p->parent;
					i = SearchBTNode(p, x);
				}
				else                    //没找到x，需要新结点
					newroot_tag = 1;
			}
		}
		if (newroot_tag == 1)              //根节点已分裂为p和q
			NewRoot(t, x, p, q,b);          //生成新的根结点，p和q都是子树指针
	}
}

这里的算法，只要认真理解一下，其实不是很难，我自己的一个难点是如何实现对记录进行处理，即对recptr的处理。这个关键就是在进行关键字的插入，移动时，记得一定要同时移动或插入相应的记录。

在这次作业中，我还遇到了几个小问题，这里顺便记一下。

  1. 比较两个字符串s1和s2，不能用s1= =s2，因为这样只是比较第一个字符，而用函数strcmp(）才是两个字符串的比较，如果s1<s2,则strcmp的返回值<0,s1= =s2，则返回值= =0，若s1>s2，则返回值>0。
  2. 字符串的定义，用strcpy()函数。
  3. 自定义结构体中，不能使用常量数据类型。

下面是一些参考资料：
https://blog.youkuaiyun.com/geek_jerome/article/details/78895289
https://blog.youkuaiyun.com/geek_jerome/article/details/78895289

最后附上完整代码：


#include "pch.h"
#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <string.h>

typedef int Status;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFESIBLE -1
#define OVERFLOW -2
// 表示函数的状态

#define MAXM  11  //定义B树的最大的阶数

const int m = 4;   //设定B树的阶数
const int Max = m - 1;          //结点的最大关键字数量
const int Min = (m - 1) / 2;    //结点的最小关键字数量
typedef char KeyType[15];         //KeyType为关键字类型

typedef struct node     //B树和B树结点类型
{
	int keynum;             //结点关键字个数
	KeyType key[MAXM];     //关键字数组，key[0]不使用
	struct node *parent;   //双亲结点指针
	struct node *ptr[MAXM];   //孩子结点指针数组
	int recptr[MAXM];       //记录指针向量，0号单元未用
}BTNode, *BTree;

typedef struct    //B树查找结果类型
{
	BTNode *pt;    //指向找到的结点
	int i;        //在结点中的关键位置
	int tag;        //查找成功与否标志
}Result;

Status InitBTree(BTree &t)
{
	t = NULL;
	return OK;
}

int SearchBTNode(BTNode *p, KeyType k)
{
	int i = 0;
	while (i < p->keynum&&strcmp(p->key[i + 1], k) <= 0)
	{
		i++;
	}
	return i;
}

Result SearchBTree(BTree t, KeyType k)
{
	BTNode *p = t, *q = NULL;      //初始化结点p和结点q，p指向待查结点，q指向p的双亲
	int found_tag = 0;              //设定查找成功与否标志
	int i = 0; 
	Result r;                     //设定返回的查找结果
	while (p != NULL && found_tag == 0)
	{
		i = SearchBTNode(p, k);                //在结点p中查找关键字k
		if (i > 0 && strcmp(p->key[i], k) == 0)      //查找成功
		{
			found_tag = 1;
		}
		else               //查找失败
		{
			q = p;
			p = p->ptr[i];
		}
	}
	if (found_tag == 1)           //查找成功
	{
		r.pt = p;
		r.i = i;
		r.tag = 1;
	}
	else                  //查找失败
	{ 
		r.pt = q;
		r.i = i;
		r.tag = 0;
	}
	return r;                //返回关键字k的位置（或者插入位置）
} 

void InsertBTNode(BTNode *&p, int i, KeyType k, BTNode *q,int a)   //在m阶B-树上结点*q的key[i]和key[i+1]之间插入关键字k
{
	int j;
	for (j = p->keynum;j > i;j--)          //整体后移空出一个位置
	{
		strcpy(p->key[j + 1], p->key[j]);
		p->recptr[j + 1] = p->recptr[j];
		p->ptr[j + 1] = p->ptr[j];
	}
	strcpy(p->key[i + 1], k);
	p->recptr[i + 1] = a;
	p->ptr[i + 1] = q;
	if (q != NULL)
		q->parent = p;
	p->keynum++;
}

void SplitBTNode(BTNode*&p, BTNode *&q)   //将p->key[s+1,...,m]，p->ptr[s+1,...,m]和p->recptr[s+1,...,m]移入新节点q
{
	int i;
	int s = (m + 1) / 2;
	q = (BTNode *)malloc(sizeof(BTNode));    //给结点q分配空间
	q->ptr[0] = p->ptr[s];
	for (i = s + 1;i <= m;i++)       //后一半移入结点q
	{
		strcpy(q->key[i - s], p->key[i]);
		q->recptr[i - s] = p->recptr[i];
		q->ptr[i - s] = p->ptr[i];
	}
	q->keynum = p->keynum - s;
	q->parent = p->parent;
	for (i = 0;i <= p->keynum - s;i++)     //修改双亲指针
	{
		if (q->ptr[i] != NULL)
			q->ptr[i]->parent = q;
	}
	p->keynum = s - 1;               //结点p的前一半保留，修改结点p的keynum
}

void NewRoot(BTNode *&t, KeyType k, BTNode *p, BTNode *q,int a)   //s生成含信息（p,q，k)的新的根节点*t，q和p为子树指针
{
	t = (BTNode *)malloc(sizeof(BTNode));    //分配空间
	t->keynum = 1;
	t->ptr[0] = p;
	t->ptr[1] = q;
	strcpy(t->key[1], k);
	t->recptr[1] = a;
	if (p != NULL)             //调整结点p和q的双亲指针
		p->parent = t;
	if (q != NULL)
		q->parent = t;
	t->parent = NULL;
}

void InsertBTree(BTree &t, int i, KeyType k, BTNode *p,int a)
{
	BTNode *q; 
	int b;
	int finish_tag, newroot_tag, s;          //设定需要新结点标志和插入完成标志
	KeyType x;
	if (p == NULL)           //t是空树
		NewRoot(t, k, NULL, NULL,a);             //生成仅含关键字k的根结点t
	else
	{
		strcpy(x,k);
		b = a;
		q = NULL;
		finish_tag = 0;
		newroot_tag = 0;
		while (finish_tag == 0 && newroot_tag == 0)
		{
			InsertBTNode(p, i, x, q,b);  //将关键字x和结点q分别插入到p->key[i+1]和p->[i+1]
			if (p->keynum <= Max)        //插入完成
				finish_tag = 1;
			else
			{
				s = (m + 1) / 2;
				SplitBTNode(p, q);         //分裂结点
				strcpy(x, p->key[s]);
				b = p->recptr[s];
				if (p->parent)         //查找x 的插入位置
				{ 
					p = p->parent;
					i = SearchBTNode(p, x);
				}
				else                    //没找到x，需要新结点
					newroot_tag = 1;
			}
		}
		if (newroot_tag == 1)              //根节点已分裂为p和q
			NewRoot(t, x, p, q,b);          //生成新的根结点，p和q都是子树指针
	}
}

int main()
{
	BTNode *t = NULL;
	Result s,i;
	int j, n = 10;
	KeyType k;
	KeyType a[10], str = {0};
	char ch[15];
	int b[10];
	srand((unsigned int)time(0));
	for (int k = 0;k < 10;k++)
	{
		b[k] = (rand()<<7)+rand();      //左移7位生成随机数
		for (int j = 0; j < 4; j++) { str[j] = rand() % 26 + 'A'; }    //随机生成字符串
		strcpy(a[k], str);
	}
	for (j = 0;j < n;j++)
	{
		s = SearchBTree(t, a[j]);
		if (s.tag == 0)
			InsertBTree(t, s.i, a[j], s.pt,b[j]);
	}
	puts("电话查询系统：");
	puts("------------------------------------------------------------------");
	for (int k = 0;k < 10;k++)
	{
		printf("%s:%d\t", a[k], b[k]);
		if (0 == k % 5&&k!=0)
			printf("\n");
	}
	printf("\n");
	puts("------------------------------------------------------------------");
	while (*ch != '0')
	{
		puts("请输入你想要找的人的姓名（区别大小写），输入0表示结束");
		scanf("%s", ch);
		i = SearchBTree(t, ch);
		if (i.tag == 0)
			puts("没有找到这个人");
		else
			printf("这个人的电话号码是：%d\n", i.pt->recptr[i.i]);
	}

}
数据结构 | 第十五章：平衡搜索树——B-树 | B-树的搜索、插入、删除
知识库搭建ing
01-12 1391
《数据结构、算法与应用（C++语言描述）》第十五章：平衡搜索树——B-树，结合课程重点的自留笔记。
B-树和B+树数据结构及B-树的创建和删除操作详细过程
qq_45566354的博客
07-02 5291
众所周知，mysql的索引用的是B+树 那么到底啥是B+树呢？今天学习了一下 下面总结一下我今天学到的知识！ 若有错误感谢纠正 首先 B-树念作B树（而不是B减树） B+树念作B加树 1、B-树 1.1、B树概念 每个结点最多有m个分支(子树) ;而最少分支数要看是否为根结点，如果是根结点且不是叶子结点则至少有2个分支，非根非叶结点至少有「m/2⌉ 个分支。 有n (k<=n<=m) 个分支的结点有n-1个关键字，它们按递增顺序排列。k=2(根结点)或「m/2⌉ (非根结点) 结点内各关键字
B树、B-树、B+树、B*树
01-25
详细分析了他们的定义和区别，配图说明。 B树：二叉树，每个结点只存储一个关键字，等于则命中，小于走左结点，大于走右结点； B-树：多路搜索树，每个结点存储M/2到M个关键字，非叶子结点存储指向关键字范围的子结点； 所有关键字在整颗树中出现，且只出现一次，非叶子结点可以命中； B+树：在B-树基础上，为叶子结点增加链表指针，所有关键字都在叶子结点中出现，非叶子结点作为叶子结点的索引；B+树总是到叶子结点才命中； B*树：在B+树基础上，为非叶子结点也增加链表指针，将结点的最低利用率从1/2提高到2/3；
B-树（高阶数据结构）
GG_Bruse的博客
02-25 5000
若树为空，直接插入新结点，该结点为树的根结点树非空，找待插入关键字在树中的插入位置（找到的插入结点位置一定是叶子结点）检测是否找到插入位置（假设树中的key唯一，即该元素已经存在时则不插入）按照插入排序的思想将该关键字插入到找到的结点中检测该结点关键字数量是否满足B-树的性质：即该节点中的元素个数是否等于M，若小于则满足，插入结束若插入后结点不满足B树的性质，需要对该结点进行分裂：申请新的兄弟结点找到该结点的中间位置将该结点中间位置右侧的元素以及其孩子搬移到新结点中。
浅析B-树
Sunnylunch-blog
11-12 1608
B树是一种适合与外查找的的搜索树，他是一种平衡的多叉树。在B树的每个结点中包含一组指针recptr[M]指向实际记录的存放地址。key[i]与recptr[i]形成一个索引项，通过key[i]可以找到某个记录的存储地址recptr[i]。 M阶的B树具有以下特点： 1、根节点要么是叶子结点，要么具有两个孩子。 2、非根结点(叶结点除外)都具有[M/2，M]个孩子。 3、非根结点都具
B-树以及B+树
slx_share的博客
10-16 568
B树 B树是一种平衡的多路查找树，包括B-树以及B+树。一个节点可以拥有多个key以及多个孩子节点。一棵m阶的B树满足如下性质： 一个节点最多含有m-1个key，大于或等于m就要对节点进行劈裂 节点上的n个key有序排列，对应n+1个孩子有序排列(例如大于第一个key对应第一个孩子节点) 根节点非空，则至少两个孩子 内部节点至少m//2+1个孩子节点 搜索 B-树和B+树都可以从根节点开始随机...
B-树（B树）详解
热门推荐
yygr的博客
02-05 3万+
https://www.jianshu.com/p/7dedb7ebe033 具体讲解之前，有一点，再次强调下：B-树，即为B树。因为B树的原英文名称为B-tree，而国内很多人喜欢把B-tree译作B-树，其实，这是个非常不好的直译，很容易让人产生误解。如人们可能会以为B-树是一种树，而B树又是一种树。而事实上是，B-tree就是指的B树。特此说明。 1、B-树(B树)的基本概念 B-树中所有结点中孩子结点个数的最大值成为B-树的阶，通常用m表示，从查找效率考虑，一般要求m>=3。一棵m阶B-树或者
B树、B-树、B+树、B树++、R-tree总结
09-20
B树、B-树、B+树以及B树++和R树是数据库和文件系统中常用的高效数据结构，它们主要用于实现磁盘或其他外部存储的查找。这些数据结构的设计目标是减少磁盘I/O操作，提高数据访问速度，因为磁盘读写速度远慢于内存。 ...
动态打印B-树代码
11-16
总结来说，动态打印B-树涉及了数据结构的基本概念，包括B-树的定义、特性、插入、创建、删除和查找操作。通过理解和实践这些知识点，不仅可以提高对数据结构的理解，也有助于提升解决实际问题的能力。
详解B-树教程.ppt
09-20
总结来说，B-树是一种优化了磁盘访问的高效数据结构，其平衡性保证了查找效率，同时通过节点分裂和合并动态调整结构，适应数据的增删。这种数据结构对于大型数据库和文件系统的索引构建至关重要。
什么是B-树？
qq_24047659的博客
03-01 8353
一、什么是B-树？ Mysql数据库用过了吧？ 里面的【索引】是基于什么【数据结构】？ 索引主要是基于【Hash表】或者【B+树】 要弄明白B+树，先要了解什么是B-树。 B-树就是【B树】，中间的横线并不是减号。 二、为什么数据库【索引】要使用【树】结构存储呢...
数据结构与算法——20.B-树
最新发布
m0_52096593的博客
04-14 1788
在介绍B树之前，我们回顾一下我们学的树。首先是二叉树，这个不用多说，然后为了查找的效率，我们提出了搜索二叉树（或者称为二叉搜索树），就是节点类加个key值，然后左边小右边大的那个。然后为了避免极端情况的出现，就是二叉搜索树节点集中在一侧的情况，我们提出了平衡二叉树，就是带自旋的，可以左旋或者右旋的，高度差小于1的那种，平衡二叉树里面有AVL树和红黑树两种实现方式，注意，平衡二叉树是在二叉搜索树的基础上提出的，所以平衡二叉树也叫平衡二叉搜索树。下面介绍一下B树。
B-和B+树
zzu-hust-madd
11-15 183
B-树是一种平衡的多路查找树，它在文件系统中很有用。一棵m阶的B-树，或为空树，或为满足下列特性的m叉树： (1)树中每个节点至多有m棵子树； (2)若根节点不是叶子节点，则至少有两棵子树； (3)除根之外的所有非终端节点至少有向上取整m/2棵子树 (4)所有的非终端节点中包含下列信息数据 (n，A0，K1，A1，K2，…，Kn，An) 其中：Ki(i=1，…，n)为关键字，且Ki<Ki+1...
数据结构：树基础
轻松的小希
03-22 1万+
目录第一章 树1.1、树的定义1.2、树的术语第二章 二叉树2.1、二叉树的定义2.2、二叉树的术语2.3、二叉树的性质第三章 二叉查找树3.1、BST的定义3.2、BST的结构3.3、BST的添加3.4、BST的获取3.4.1、获取指定值3.4.2、获取最小键3.4.3、获取最大键3.4.4、获取树深度3.5、BST的删除3.5.1、删除最小结点3.5.2、删除最大结点3.5.3、删除指定结点3.6、BST的遍历3.6.1、前序遍历3.6.2、中序遍历3.6.3、后序遍历3.6.4、层序遍历3.7、BST
树的基本术语
只是个人笔记，请见谅
11-07 1万+
树的基本术语结点根节点结点的度非终端结点与终端结点双亲与孩子兄弟堂兄弟祖先与子孙树的深度有序树与无序树森林线性表与树的比较   结点 数据元素以及指向子树的分支   根节点 非空树中无前驱结点的结点   结点的度 该结点最多的分支个数   非终端结点与终端结点 非终端结点：度不为0，且不是根结点的分支结点叫非终端结点，也称内部结点 终端结点：度为0,叫终端结点，也称叶子   双亲与孩子 结点的前缀叫双亲 结点的后缀叫孩子   兄弟 有
B树
geek_jerome的博客
11-29 596
B树定义 B树，称为多路平衡查找树。B树中所有结点的孩子结点树的最大值称为B树的阶，通常称为m。一颗m阶B树或为空树，或为满足以下特性的m叉树： 1.树中每个结点至多有m棵子树（至多含有m-1个关键字） 2.若根结点不是终端结点，则至少有两颗子树 3.除根结点外的所有非叶结点至少有【m/2】棵子树。（至少含有【m/2】-1个关键字）【】是向上取整符号。 4.所有的叶结点都出现在同一层次上，
B-树自在人心|B树的原理与实现
weixin_46096297的博客
03-31 4162
关于B-树的构造原理，代码；有序输出原理、代码；删除原理、代码实现
B-（B树）、B+树、B*树以及红黑树的理解
古月广大的博客
07-17 895
1、首先要明白为什么有了AVL树之后还会出现这么多树的变种？ 可以参考这个知乎有关几种树的应用的回答: 作者：王伟豪 链接：https://www.zhihu.com/question/30527705/answer/52919336 来源：知乎 原文链接：https://blog.youkuaiyun.com/herr_kun/article/details/80550652 AVL树：平衡二叉树，一般是用平衡因子差值决定并通过旋转来实现，左右子树树高差不超过1，那么和红黑树比较它是严格的平衡二叉树，平衡条件
关于B树的思考：m阶B树的非根非叶节点为什么要至少为ceil(m/2)个孩子？
oxygen's blog
10-19 1万+
非根非叶子节点 因为小于ceil(m/2)时可以进行合并。
B-树可视化演示系统的设计与实现
总结来说，可视化B-树演示系统是一个结合了数据结构、计算机图形学和用户界面设计的软件，它可以动态地展示B-树数据结构的构建过程，对教育和实际应用都具有很高的价值。通过该系统，用户不仅能够学习到B-树的理论...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值