数据结构 树&图

已于 2024-03-05 21:51:25 修改
阅读量594 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2021-09-02 22:31:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53459056/article/details/120069473
版权

目录

二叉树

二叉树的代码实现

哈夫曼树

基本概念

哈夫曼树的代码实现

 一.哈夫曼树的构成

 二、创建哈夫曼树

 三.为哈夫曼树编码

孩子兄弟树

二叉树

 二叉树：每个结点最多有2个子结点

二叉树的代码实现

结构体

typedef int BTElemType;

typedef struct BiTreeNode {
	BTElemType data;
	BiTreeNode* lChild;
	BiTreeNode* rChild;
}*BiTree;

 初始化

由于很多语句都需要判断结点存不存在，因此二叉树的初始化就是T=NULL

相似的，之后在创建树时，每个结点的左右孩子一开始也需要=NULL

保证结点被声明时=NULL,左右孩子被赋值之前=NULL,直到有值赋给他们，否则指针会变成野指针

//初始化
void InitBT(BiTree& T) {
	T = NULL;

}

//判树空（无任何结点）
bool BTIsEmpty(BiTree T) {
	if (!T)
		return true;
	else
		return false;
}

 前序创建树

 理解：

1.将二叉树T传入函数，首先输入一个元素e

2.若e非0，T->data=e;   T->lChild=NULL;  T->rChild=NULL;

3. T的左右孩子先后调用此函数，不断创建

//前序创建树（输入非0值）
void CreatBT(BiTree& T) {
	BTElemType e;
	cin >> e;
	InitBT(T);
	if (e!=0) {
		T = (BiTree)malloc(sizeof(BiTreeNode));
		if (!T)
			exit(OVERFLOW);
		T->data = e;
		T->lChild = NULL;
		T->rChild = NULL;
		CreatBT(T->lChild);
		CreatBT(T->rChild);
	}
}

 二叉树的遍历（前中后、层序遍历）

前中后序遍历的区别即是   访问左子树、右子树、根节点的顺序不同


前序遍历：传进结点->输出data->左孩子递归->右孩子递归

中序遍历：相当于一直找到左孩子不存在的结点，输出本结点data，再右孩子递归

后序遍历：从左子树开始找，找到底层（左右孩子都为NULL了），输出那个结点，再向上回溯

//前序遍历
void PreOrderTraverse(BiTree T) {
	if (T) {
		cout << T->data << " ";
		PreOrderTraverse(T->lChild);
		PreOrderTraverse(T->rChild);
	}
}

//中序遍历
void InOrderTraverse(BiTree T) {
	if (T) {
		InOrderTraverse(T->lChild);
		cout << T->data << " ";
		InOrderTraverse(T->rChild);
	}
}

//后序遍历
void NextOrderTraverse(BiTree T) {
	if (T) {
		NextOrderTraverse(T->lChild);
		NextOrderTraverse(T->rChild);
		cout << T->data << " ";
	}
}

 层序遍历：用队列，存储每一层的结点

从根节点开始入队，只要队不空，出队，输出data，再将当前节点的左右孩子入队

//层序遍历
void LevelOrderTraverse(BiTree T) {
	LinkQueue Q;
	BiTree p;			//存储出队的
	if (T) {
		InitLQ(Q);
		EnLQ(Q, (LQElemType)T);
		while (!LQIsEmpty(Q)) {
			DeLQ(Q, (LQElemType&)p);
			cout << p->data << " ";
			if (p->lChild)
				EnLQ(Q, (LQElemType)p->lChild);
			if (p->rChild)
				EnLQ(Q, (LQElemType)p->rChild);
		}
	}

}

 求树的深度

//求树的深度
int BTDepth(BiTree T) {
	int lDepth, rDepth;
	if (!T)
		return 0;
	lDepth = BTDepth(T->lChild);
	rDepth = BTDepth(T->rChild);
	if (lDepth >= rDepth)
		return lDepth + 1;
	else
		return rDepth + 1;
}

 理解！！！

（1）如果一颗树只有一个结点，它的深度是 1；
（2）如果根结点只有左子树而没有右子树，那么二叉树的深度应该是其左子树的深度加 1；
（3）如果根结点只有右子树而没有左子树，那么二叉树的深度应该是其右树的深度加 1；
（4）如果根结点既有左子树又有右子树，那么二叉树的深度应该是其左右子树的深度较大值加 1

——>

如果这个结点为空，它对深度的贡献就是0，返回给上一层;

向上回溯，每层贡献的深度是下一层返回的深度+1（这个1是本结点贡献的深度）

向上回溯过程中，返回的是lDepth和rDepth中的较大值，因为——根节点到叶结点的最长路径为二叉树的深度

哈夫曼树

基本概念

1、权
2、路径：从树中的一个结点到另一个结点

1）路径长度：路径上的分支数                
2）树的路径长度：从树根到每个结点的路径长度之和

 3）结点的带权路径长度：从该结点到树根之间的路径长度与结点上权的乘积
 4）树的带权路径长度：树中所有带权结点的路径长度之和

3、哈夫曼树：带权路径长度最小的树

哈夫曼树的代码实现

 一.哈夫曼树的构成

一棵有n个叶子结点的哈夫曼树中，度为2的结点有n-1个，则共有2n-1个结点，可以用大小为2n-1的一维数组来存储

每个数组元素是这样的结构体：

 结构体

typedef struct HuffmanTreeNode {
	int lChild, rChlid, parent;  
	int weight;		
}*HuffmanTree;

 二、创建哈夫曼树

 1.初始化 

1）为HT开辟2n-1（total）个存储单元 

 2）初始化每个单元，0~n个单元，左右孩子、双亲初始化为-1（由于-1不存在，所以实际上的意思是初始化的时候先都标记为无），第 i 个的权值为传进来的数组元素weight[i]       

 n~total个单元，左右孩子、双亲初始化为-1，第 i 个的权值为0（也是初始化思想）

2.创建树

n~total是新添加的数，在n~total循环，把其前边最小的数和第二小的数变成它的左右孩子下标，左右孩子的parent下标变成它的下标，它的权值为左右孩子之和


//返回前k个最小的权值
int Min(HuffmanTree HT, int k) {
	int i = 0;
	int min;
	while (HT[i].parent != -1)		//从下标0找到第一个没有父结点的，从它开始找
		i++;
	min = i;			//将其暂时赋值给min
	//i到k找到最小权值的下标
	for (; i < k; i++)
		//如果一样，则返回前面的
		if (HT[i].weight < HT[min].weight && HT[i].parent == -1)
			min = i;
	HT[min].parent = 1;		//改变parent的值，下次就不找这个点了
	return min;
}

void CreatHuffmanTree(HuffmanTree& HT, int* weight, int n) {
	int total = 2 * n - 1;    //remember
	HT = new HuffmanTreeNode[total];  //给传进来的赫夫曼树分配空间，一共有total个结构体
	if (!HT)
		exit(OVERFLOW);
	//给每个结构体初始化
	for (int i = 0; i < n; i++) {
		HT[i].lChild = HT[i].rChlid = HT[i].parent = -1;
		HT[i].weight = weight[i];
	}
	for (int i = n; i < total; i++) {
		HT[i].lChild = HT[i].rChlid = HT[i].parent = -1;
		HT[i].weight = 0;
	}
	for (int i = n; i < total; i++) {
		//先找的min1，所以min1一定是小于min2的，它在前边
		int min1 = Min(HT, i);
		int min2 = Min(HT, i);

		HT[min1].parent = HT[min2].parent = i;
		//给HT[i]的各种成员赋值
		HT[i].weight = HT[min1].weight + HT[min2].weight;
		HT[i].lChild = min1;
		HT[i].rChlid = min2;
	}
}

 三.为哈夫曼树编码

1、基本思想：概率大的字母用短码，小的用长码，构造哈夫曼树，概率越大，路径越短。
2、哈夫曼编码：在哈夫曼的每个分支上标上0或1
——结点的左分支标0，右分支标1
——把从根到每个叶子的路径上的标号连接起来，构成一个二进制串，该二进制串就成为该叶子代表的哈夫曼编码

编码

1）二维数组code存放n个叶结点的编码 

2）tempCoding是一个在结尾放了空字符的临时字符串指针

3）从0~n,cur为当前数据的下标，parent为其双亲，start用于指向编码在tempCoding中的位置，初始时指向最后一个（n-1）

4）当不是根结点时，左0右1进行赋值，再把当前数据改为其双亲数据，继续向上编码

5）tempCoding+start是当前开始有编码的位置，把编码copy给code[i]

void HuffmanCoding(HuffmanTree T, char**& code, int n) {
	code = new char* [n];
	if (!code)
		exit(OVERFLOW);
	char* tempCoding = (char*)malloc(n * sizeof(char));
	if (!tempCoding)
		exit(OVERFLOW);
	tempCoding[n - 1] = '\0';

	for (int i = 0; i < n; i++) {
		int cur = i;
		int parent = T[i].parent;
		int start = n - 1;
		//当未到根结点时
		while (parent != -1) {
			//左0右1
			if (T[parent].lChild == cur)
				tempCoding[--start] = '0';
			else if (T[parent].rChlid == cur)
				tempCoding[--start] = '1';
			cur = parent;
			parent = T[cur].parent;
		}
		code[i] = (char*)malloc((n - start) * sizeof(char));
		if (!code[i])
			exit(OVERFLOW);
		strcpy(code[i], tempCoding + start);
	}
	for (int i = 0; i < n; i++)
		cout << code[i] << endl;
}

孩子兄弟树

结构体

typedef struct CSTreeNode {
	CSTElemType data;
	CSTreeNode* firstChild, * nextSibling;
}*CSTree;

  

和二叉树相比较，把左孩子右孩子换成了首孩子和兄弟

初始化和创建树

 创建树时：

输入非零值创建树的根结点

和二叉树一开始的赋值类似，data存储输入的值e,让两个指针指空

结点入队

当队伍不为空时：

将输入的第一个结点存为当前结点的首孩子，将剩下的输入存为它孩子的兄弟

//初始化树
void InitTree(CSTree& T) {
	T = NULL;
}

//创建树
void CreatTree(CSTree& T) {
	LinkQueue Q;
	CSTElemType e;
	cout << "请输入根节点" << endl;
	cin >> e;
	CSTree p;

	//有树
	if (e != 0) {
		InitLQ(Q);
		T = (CSTree)malloc(sizeof(CSTreeNode));
		if (!T)
			exit(OVERFLOW);
		T->data = e;
		T->firstChild = NULL;
		T->nextSibling = NULL;

		EnLQ(Q, (LQElemType)T);
		while (!LQIsEmpty(Q)) {
			DeLQ(Q, (LQElemType&)p);
			cout << "请输入" << p->data << "的孩子个数" << endl;

			int childNum;
			cin >> childNum;

			//有树
			if (childNum > 0) {
				cout << "请输入" << p->data << "的" << childNum << "个孩子值" << endl;
				cin >> e;
				CSTree q;
				q = (CSTree)malloc(sizeof(CSTreeNode));
				if (!q)
					exit(OVERFLOW);
				q->data = e;
				q->firstChild = NULL;
				q->nextSibling = NULL;
				p->firstChild = q;
				p = q;
				EnLQ(Q, (LQElemType)q);

				for (int i = 1; i < childNum; i++) {
					cin >> e;
					CSTree q2 = (CSTree)malloc(sizeof(CSTreeNode));
					if (!q2)
						exit(OVERFLOW);
					q2->data = e;
					q2->firstChild = NULL;
					q2->nextSibling = NULL;

					p->nextSibling = q2;
					p = q2;
					EnLQ(Q, (LQElemType)q2);
				}
			}
		}
		DestroyLQ(Q);
	}
}

遍历

 前序遍历：和二叉树的前序遍历思路类似

层序遍历：输出根结点的值，入队->当队不空：输出当前结点的首孩子，按次输出该孩子的右兄弟

//前序遍历
void PreOrderTraverse(CSTree T) {
	if (T) {
		cout << T->data << " ";
		PreOrderTraverse(T->firstChild);
		PreOrderTraverse(T->nextSibling);
	}
}

//层序遍历
void LevelOrderTraverse(CSTree T) {
	LinkQueue Q;
	CSTree p, q;
	if (T) {
		cout << T->data << " ";
		InitLQ(Q);
		EnLQ(Q, (LQElemType)T);
		while (!LQIsEmpty(Q)) {
			DeLQ(Q, (LQElemType&)p);
			if (p->firstChild) {
				q = p->firstChild;
				while (q) {
					EnLQ(Q, (LQElemType)q);
					cout << q->data << " ";
					q = q->nextSibling;
				}
			}
		}
	}
}

销毁

 先深入到最后一个首孩子，再找到它的最后一个右兄弟，从右到左，从下到上（这个方向仅用于自己理解。。），向上回溯，用free()释放其空间

//销毁树
void DestroyTree(CSTree& T) {
	if (T) {
		DestroyTree(T->firstChild);
		DestroyTree(T->nextSibling);
		free(T);
		T = NULL;
	}
}

 求树深度

//求树深度
int TreeDepth(CSTree T) {
	CSTree p;
	int depth, max = 0;
	if (!T)
		return 0;
	for (p = T->firstChild; p; p = p->nextSibling) {
		depth = TreeDepth(p);
		if (depth > max)
			max = depth;
	}
	return max + 1;
}

 SomeFunctions


//返回p结点值
CSTElemType Value(CSTree p) {
	return p->data;
}

//返回根节点值
CSTElemType Root(CSTree T) {
	if (T)
		return Value(T);
	else
		return 0;
}

//返回值为e的结点
CSTree Point(CSTree T, CSTElemType e) {
	LinkQueue Q;
	CSTree p;
	if (T) {
		InitLQ(Q);
		EnLQ(Q, (LQElemType)T);
		while (!LQIsEmpty(Q)){
			DeLQ(Q,(LQElemType&)p);
			if (p->data == e)
				return p;
			if (p->firstChild)
				EnLQ(Q, (LQElemType)p->firstChild);
			if (p->nextSibling)
				EnLQ(Q, (LQElemType)p->nextSibling);
		}
	}
	return NULL;
}

//求值为e的双亲结点值
CSTElemType Parent(CSTree T, CSTElemType e) {
	LinkQueue Q;
	CSTree p, q;
	if (T) {
		InitLQ(Q);
		EnLQ(Q, (LQElemType)T);
		while (!LQIsEmpty(Q)) {
			DeLQ(Q, (LQElemType&)p);
			if (p->firstChild) {
				q = p->firstChild;
				while (q && q->data != e) {
					EnLQ(Q, (LQElemType)q);
					q = q->nextSibling;
				}
				if (q)
					return p->data;
			}
		}
	}

	return NULL;
}

//求值为cur_e的最左孩子
CSTElemType LeftChild(CSTree T, CSTElemType cur_e) {
	CSTree p = Point(T, cur_e);
	if (p && p->firstChild)
		return p->firstChild->data;
	return 0;
}

//求值为cur_e的右兄弟
CSTElemType rightSibling(CSTree T, CSTElemType cur_e) {
	CSTree p = Point(T, cur_e);
	if (p && p->nextSibling)
		return p->nextSibling->data;
	else
		return 0;
}

//插入孩子:将c插入到p结点的i个位置
status InsertChild(CSTree& T, CSTree p, int i, CSTree c) {
	int j;
	CSTree q;
	if (T) {
		//插入到长子位置
		if (i == 1) {
			c->nextSibling = p->firstChild;
			p->firstChild = c;
		}
		else {
			int j = 1;
			q = p->firstChild;
			while (q && j < i - 1) {
				q = q->nextSibling;
				j++;
			}
			if (!q || j > i - 1)			//q是插入的点前一个
				return ERROR;		//位置错误
			c->nextSibling = q->nextSibling;
			q->nextSibling = c;

		}
		return OK;
	}
	else {
		return ERROR;
	}
}

//删除p结点的第i棵子树
status DeleteChild(CSTree& T, CSTree p, int i) {
	CSTree q, t;

	if (p) {
		if (i == 1) {
			q = p->firstChild;
			p->firstChild = q->nextSibling;
			q->nextSibling = NULL;
			DestroyTree(q);
		}
		else {
			int j = 1;
			q = p->firstChild;
			while (q && j < i - 1) {
				q = q->nextSibling;
				j++;
			}
			if (!q || j > i - 1)
				return ERROR;
			t = q->nextSibling;		//t是要删除的点
			q->nextSibling = t->nextSibling;
			t->nextSibling = NULL;
			DestroyTree(t);
		}
		return OK;
	}
	else
		return ERROR;
}

Micmic33
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构图和树的区别_树和图数据结构之间的区别
culing2941的博客
09-15 8785
数据结构图和树的区别In this tutorial you will learn about the difference between tree and graph. 在本教程中，您将了解树和图之间的区别。 Both trees and graphs are two well known mostly used data structures in algorithms. 树和图都是算...
常见数据结构详细图解、树的高度、深度、层数、跳表、二叉搜索树、平衡二叉树、红黑树、B树、B+树
qq_40585384的博客
01-08 4655
树中的每个节点，它的左子树中所有关键字值小于该节点关键字值，右子树中所有关键字值大于该节点关键字值
数据结构基础——树、图，堆
大风的博客
09-28 5521
树 树是一种非线性的结构，一般来说树形结构中，只有一个根节点，而在树其他节点中有且只能有一个前驱节点。我们常说的树结构，一般说的为二叉树，而实际中我们使用的树形结构不仅仅限于一个二叉树。 定义 对于一个有n个元素的树，当n为0的时候称为空树。其定义有下面要求： 树有且仅有一个特定节点为其根节点 当n>1时，其余结点可分为m(m>0)个互补交互的有限集T1、T2…Tm，其中每一个集合本...
数据结构 串 树 图
m0_48214736的博客
09-14 591
数据结构4-6章 串，树，图
【数据结构】之树的介绍
胖狗子修行之路的博客
09-26 1198
目录 树 二叉树 满二叉树 完全二叉树 二叉树的链式存储 二叉树的遍历 树 树的定义：一棵树是若干个结点的集合，它由唯一的根结点与若干互不相交的子树组成。其中每棵子树也是由唯一的根结点与若干个互不相干的子树构成。树的定义是递归的。 结点的度：结点拥有子树的个数 叶结点：结点度为零的结点 二叉树 二叉树：属于树，且满足：1）每个节点至多两个子树。2）二叉树是有序的，左右...
数据结构-红黑树.zip
最新发布
03-21
红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。这种数据结构由Rudolf Bayer在1972年首次提出，当时被称为平衡二叉B树（Symmetric Binary B-...
数据结构&示例代码.zip
02-12
常见的数据结构有数组、链表、栈、队列、树、图等。数组是最基础的数据结构，它在内存中存储相同类型的数据元素，并通过索引进行访问。链表则由一系列节点组成，每个节点包含数据以及指向下一个节点的指针，允许在...
经典四叉树数据结构C#实现
12-07
用C#实现的经典四叉树数据结构，代码简单易懂，适合初学者学习
头歌数据结构图的最小生成树算法
05-26
头歌数据结构图的最小生成树算法 第1关求图（邻接矩阵存储）最小生成树的普里姆（Prim）算法 第2关求图（邻接表存储）最小生成树的普里姆（Prim）算法 第3关求图（邻接矩阵存储）最小生成树的克鲁斯卡尔（Kruskal）...
数据结构课程设计哈夫曼树.doc
12-18
数据结构的基本概念包括数组、链表、栈、队列、树、图等。这些数据结构的设计和实现对于软件开发、算法设计和数据分析等领域至关重要。 1.1 数组 数组是一种基本的数据结构，它是一组相同类型的元素的集合。数组...
数据结构之树和图相关笔记
离散梦
07-08 4255
作者：离散梦 欢迎大家给出宝贵的建议！   数据结构之树和图相关笔记   树的定义：     树（Tree）是n（n&gt;=0）个节点的有限集。n=0时称为空树。     在任意一棵非空树中：     （1）有且仅有一个特定的称为根（Root）的节点；     （2）当n&gt;1时，其余节点可分为m（m&gt;0）个互不相交的有限集T1、T2、......、Tm，其中每一个集...
数据结构(链表、链栈、链队列、二叉树、图)
attitude_yu
05-02 1万+
本文用于总结数据结构(链表、链栈、链队列、二叉树、图)的创建方式与遍历方式！！！ 本目录代码已上传至github中！！！ 1. 链表 1. 线性表顺序存储和链式存储的优缺点？ 顺序存储： a.不需要增加额外的存储空间，快速存取指向位置的元素； b.在插入和删除过程中，需要移动大量元素； c.需要预先分配存储空间； 链式存储： a.插入删除操作时间为O(1); b.用任意位置的存储单元存...
数据结构与算法 -- 树结构与图结构
Rabbit_Judy的博客
12-27 4865
树的概念 形式化定义：算法的集合树(Tree)是由一个或多个结点组成的有限集合T，其中有一个特定的称为根的结点；其余结点可分为(m≥0)个互不相交的有限集T1,T2,T3,…,Tm，每一个集合本身又是一棵树，且称为根的子树。 逻辑结构： 树的表示： 图形表示法 表表示法：(A(B(E,F),C(G),D(H,I,J))) 树的术语： 结点的度：结点子树个数为结点的度 树的度：树中...
数据结构的树和图
New_new_zero的博客
08-06 328
// 数据结构 /* 根既可以是叶子节点，也可以是非叶子节点（非终端节点） 树的深度：最大层数 节点的度：子节点个数 树的度：最大子节点个数 树的权：所有叶子结点值的和 二叉树：子节点个数为2，且有序 二叉树分类： 一般二叉树： 满二叉树：每一层节点数都是最大的 完全二叉树：满二叉树最下面层上从右往左，删除若干个节点 满二叉树肯定是完全二叉树 森林：多个树 / / 连续存储【完全二叉树】： 优点： 快速查询某节点的父节点和子节点（包括判断有无） 缺点： 耗内存 / / 普通树转化为二叉树： 步骤：兄弟间连线
数据结构——堆、栈、队列、树、图
hailoneko的博客
07-22 5775
数据结构中的堆栈： 堆可以看成一棵按顺序排列的完全二叉树，根节点可以为大于等于任何子节点（也可以小于等于任意子节点，看具体的排序方法），在存取时没有任何限制，可以随意的访问某一个子节点。 栈或者称为堆栈（stack），可以看成是一些堆起来的盘子，桶状线性数据结构。但是栈是受限制的线性数据结构，只允许先进后出，并且只能在栈顶进行插入删除操作。 内存区的堆栈： 首先了解下内存区：堆区存放程序员...
数据结构之树结构详解
热门推荐
Smile yourlife
04-22 1万+
树的定义 树是一种很特别的数据结构，树这种数据结构叫做“树”就是因为它长得像一棵树。但是这棵树画成的图长得却是一棵倒着的树，根在上，叶在下。 树是图的一种，树和图的区别就在于：树是没有环的，而图是可以有环的。 树的百度定义如下： 树状图是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 结合图来看，可能会更好理解 这就是一棵典型的二叉树 而这里，2,3共有子节点5，那么.
数据结构5-树与图
pleboyzha的博客
03-25 721
数据结构5-树与图 树形结构是一类重要的非线性数据结构 树是以分支关系定义的层级结构；数结构在客观世界中广泛存在（如人类社会族谱，社会组织机构关系等），同时在计算机领域以及数据库系统，树形结构也是重要的组织形式； 1.树的定义 由n个结点组成的有限集，n=0空树 n>0 有且仅有一个称做根的结点 n>1 互不相交的 2.树中基本的概念 结点的度: 结点的子树个数 度为0的结点 ---> 终端结点 叶子结点 树的度
数据结构——树
zhenaoxi1077的博客
05-22 7644
图片来源：https://www.cnblogs.com/willwu/p/6007555.html 树其实就是不包含回路的连通无向图。 树的特性： 1）一棵树中的任意两个结点有且仅有唯一的一条路径连通； 2）一棵树如果有nnn个结点，则它一定有n−1n−1n-1条边； 3）在一棵树中加一条边将会构成一个回路。 树这种数据结构的用途： 例如：家族的族谱图、公司的组织结构图、书的目录等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值