C语言二叉树程序

最新推荐文章于 2022-07-10 15:27:14 发布
最新推荐文章于 2022-07-10 15:27:14 发布
阅读量1.1k 收藏 5
点赞数 1
分类专栏： 树 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woaha/article/details/76408333
版权

main.c文件

#include "BTree.h"
#include <stdio.h>
#include "LinkQueue.h"
#include "LinkStack.h"

void printData(BTreeNode* node)
{
	printf ("%c\n", node->data);
}

void pre_order(BTreeNode *root)
{
	if (root == NULL)
		return;
	
	printf ("%4c", root->data);
	pre_order (root->lchild);
	pre_order (root->rchild);
}

// 非递归方式实现前序遍历
void pre1(BTreeNode *root)
{
	if(root == NULL)
		return;
	
	LinkStack *stack =  CreateStack();
	BTreeNode* p = root;
	
	while (p != NULL || !StackEmpty(stack))
	{
		while(p)
		{
			printf ("%4c", p->data);
			Push(stack, p);
			p = p->lchild;
		}
		
		if (!StackEmpty(stack))
		{
			Pop (stack, &p);
			p = p->rchild;
		}
	}
}

void mid_order(BTreeNode *root)
{
	if (root == NULL)
		return;
	
	mid_order (root->lchild);
	printf ("%4c", root->data);
	mid_order (root->rchild);
}

// 非递归方式实现中序遍历
void mid1(BTreeNode *root)
{
	if(root == NULL)
		return;
	
	LinkStack *stack =  CreateStack();
	BTreeNode* p = root;
	
	while (p != NULL || !StackEmpty(stack))
	{
		while(p)
		{
			Push(stack, p);
			p = p->lchild;
		}
		
		if (!StackEmpty(stack))
		{
			Pop (stack, &p);
			printf ("%4c", p->data);
			p = p->rchild;
		}
	}
}

void last_order(BTreeNode *root)
{
	if (root == NULL)
		return;
	
	last_order (root->lchild);
	
	last_order (root->rchild);
	printf ("%4c", root->data);
}

void level_order(BTreeNode *root)
{
	if (root == NULL)
		return;
	
	LinkQueue * queue = CreateQueue();
	EnQueue (queue, root);  // 根节点进队
	
	while (!QueueEmpty(queue))
	{
		// 队头元素出队
		BTreeNode* p = NULL;
		DeQueue(queue, &p);
		printf ("%4c", p->data);
		if (p->lchild != NULL)
			EnQueue(queue, p->lchild);  // 左节点入队
		
		if (p->rchild != NULL)
			EnQueue(queue, p->rchild);  // 右节点入队
	}
	
	free(queue);
}

int main()
{
	BTree * btree = Create_Btree();
	if (btree == NULL)
		return -1;
	
	printf ("二叉树创建成功\n");
	
	Btree_Insert(btree, 'A', 0, 0, 0);
	Btree_Insert(btree, 'B', 0, 1, 0);
	Btree_Insert(btree, 'C', 1, 1, 0);
	Btree_Insert(btree, 'D', 0, 2, 0);
	Btree_Insert(btree, 'E', 2, 2, 0);
	Btree_Insert(btree, 'H', 3, 2, 0);
	Btree_Insert(btree, 'G', 0, 3, 0);
	Btree_Insert(btree, 'F', 6, 3, 0);
	
	DisPlay(btree, printData, 4, '-');
	printf ("前序遍历：\n");
	pre_order (btree->root);
	printf ("\n");
	pre1(btree->root);
	printf ("\n");
	
	printf ("中序遍历：\n");
	mid_order (btree->root);
	printf ("\n");
	mid1(btree->root);
	printf ("\n");
	
	printf ("后序遍历：\n");
	last_order (btree->root);
	printf ("\n");
	
	printf ("层次遍历：\n");
	level_order (btree->root);
	printf ("\n");
	
#if 0	
	//Delete(btree, 0, 1);
	printf ("--------------------------\n");
	//DisPlay(btree, printData, 4, '-');
	BTreeNode* node  = BTree_Get(btree, 0, 1);
	printf ("%c\n", node->data);
	printf ("height : %d\n", BTree_Height(btree));
	printf ("degree : %d\n", BTree_Degree(btree));

	BTree_Clear(btree);
	DisPlay(btree, printData, 4, '-');
#endif
	return 0;
}

LinkQueue.c文件

#include "LinkQueue.h"
#include <stdlib.h>
#include <assert.h>

LinkQueue * CreateQueue()
{
	LinkQueue * queue = (LinkQueue*)malloc(sizeof(LinkQueue)/sizeof(char));
	assert (queue);
	
	// 置空队
	queue->front = NULL;
	queue->rear  = NULL;
	
	return queue;
}

// 如果空队返回真，非空队返回假
int QueueEmpty (LinkQueue *Q)
{
	assert (Q);
	
	return Q->front == NULL;
}

int EnQueue (LinkQueue *Q, QueueData x)
{
	assert (Q);
	
	QueueNode * node = (QueueNode*)malloc(sizeof(QueueNode)/sizeof(char));
	assert(node);
	node->data = x;
	node->next = NULL;
	
	if (QueueEmpty(Q))
	{
		Q->front = node;
		Q->rear  = node;
	}
	else
	{
		Q->rear->next = node;
		Q->rear = node;
	}

	return OK;
}

int DeQueue (LinkQueue *Q, QueueData *x)
{
	assert (Q);
	
	if (QueueEmpty(Q))
		return ERROR;
	
	QueueNode *p = Q->front;
	Q->front = p->next;
	*x = p->data;
	free(p);
	
	// 空队的状态
	if (Q->front == NULL)
		Q->rear = NULL;

	return OK;
}
int GetFront (LinkQueue *Q, QueueData *x)
{
	assert (Q);
	
	if (QueueEmpty(Q))
		return ERROR;
	
	*x = Q->front->data;
	
	return OK;
}

Btree.c文件

#include "BTree.h"
#include <stdlib.h>
#include <stdio.h>


BTree * Create_Btree()
{
	BTree *tree = (BTree*)malloc(sizeof(BTree)/sizeof(char));
	if (tree == NULL)
		return NULL;
	
	tree->root  = NULL;
	tree->count = 0;
	
	return tree;
}


int Btree_Insert(BTree* btree, BTreeData data, int pos, int count, int flag)
{
	if (btree == NULL || (flag != BLEFT && flag != BRIGHT))
		return -1;
	
	// 新建结点
	BTreeNode * node = (BTreeNode*)malloc(sizeof(BTreeNode)/sizeof(char));
	if (node == NULL)
		return -1;
	node->data = data;
	node->lchild = NULL;
	node->rchild = NULL;
	
	BTreeNode* parent  = NULL;
	BTreeNode* current = btree->root;   // 从根节点开始找
	int way = 0;
	// 寻找插入的位置
	while(count > 0 && current != NULL)
	{
		// 当前往哪走
		way = pos & 1;
		pos = pos >> 1;
		
		// 走完了之后当前结点就变成走完之后结点的双亲结点
		parent = current;
		
		if (way == BLEFT)
			current = current->lchild;
		else 
			current = current->rchild;
		
		
		count--;
	}
	
	// 将插入位置的结点挂到新结点下面
	if (flag == BLEFT)
		node->lchild = current;
	else
		node->rchild = current;
	
	// 通过最后一次走的路线判断新节点应该挂在双亲结点的什么位置
	if (parent != NULL)
	{
		if (way == BLEFT)
			parent->lchild = node;
		else
			parent->rchild = node;
	}
	else
	{
		btree->root = node;   // 如果没有根节点（空树）将当前结点当作根节点
	}
	
	btree->count++;
	
	return 0;
}

void r_display(BTreeNode* node, BTree_Print pfunc, int format, int gap, char div)
{
	int i;
	if (node == NULL)
	{

		for(i = 0; i < format; i++)
		{
			printf ("%c", div);
		}
		printf ("\n");
		return;
	}
		
	for(i = 0; i < format; i++)
	{
		printf ("%c", div);
	}
	pfunc(node);
	
	if (node->lchild != NULL || node->rchild != NULL)
	{
		// 打印左孩子
		r_display(node->lchild, pfunc, format+gap, gap, div);

		// 打印右孩子
		r_display(node->rchild, pfunc, format+gap, gap, div);	
	}
}

void DisPlay(BTree* btree, BTree_Print pfunc, int gap, char div)
{
	if (btree == NULL)
		return;
	
	r_display(btree->root, pfunc, 0, gap, div);
}


void r_delete(BTree* btree, BTreeNode* node)
{
	if (node == NULL)
		return;
	
	r_delete(btree, node->lchild);
	r_delete(btree, node->rchild);
	
	free(node);
	node = NULL;
	btree->count--;
}


int Delete(BTree* btree, int pos, int count)
{
	if (btree == NULL)
		return -1;
	
	BTreeNode* parent  = NULL;
	BTreeNode* current = btree->root;
	int way = 0;
	while (count > 0 && current != NULL)
	{
		way = pos & 1;
		pos = pos >> 1;
		
		parent = current;
		if (way == BLEFT)
			current = current->lchild;
		else
			current = current->rchild;
		
		count--;
	}
	
	if (parent != NULL)
	{
		if (way == BLEFT)
			parent->lchild = NULL;
		else
			parent->rchild = NULL;
	}
	else
	{
		btree->root = NULL;
	}
	
	r_delete(btree, current);
	
	return 0;
}

BTreeNode* BTree_Get(BTree* tree, int pos, int count)
{
	if (tree == NULL)
		return NULL;
	
	BTreeNode* parent  = NULL;
	BTreeNode* current = tree->root;
	int way = 0;
	while (count > 0 && current != NULL)
	{
		way = pos & 1;
		pos = pos >> 1;
		
		parent = current;
		if (way == BLEFT)
			current = current->lchild;
		else
			current = current->rchild;
		
		count--;
	}
	
	return current;
}

BTreeNode* BTree_Root(BTree* tree)
{
	return tree->root;
}

int r_height(BTreeNode* node)
{
	if (node == NULL)
		return 0;
	
	// 左孩子结点的高度
	int lh = r_height(node->lchild);
	
	// 右孩子结点的高度
	int rh = r_height(node->rchild);
	
	return (lh > rh ? lh+1 : rh+1);
}

int BTree_Height(BTree* tree)
{
	if (tree == NULL)
		return 0;
	
	r_height(tree->root);
}

int r_degree(BTreeNode* node)
{
	if (node == NULL)
		return 0;
	
	int ret = 0;
	if (node->lchild != NULL)
		ret++;
	if (node->rchild != NULL)
		ret++;
	
	if (ret == 1)
	{
		int ld = r_degree(node->lchild);
		int rd = r_degree(node->rchild);
		
		if (ret < ld)
			ret = ld;
		if (ret < rd)
			ret = rd;
	}
	
	return ret;
}

int BTree_Degree(BTree* tree)
{
	if (tree == NULL)
		return 0;
	
	return r_degree(tree->root);
}


int BTree_Count(BTree* tree)
{
	return tree->count;
}

void BTree_Clear(BTree* tree)
{
	if (tree == NULL)
		return;
	
	Delete(tree, 0, 0); // 删除根节点
	
	tree->root = NULL;
}
void BTree_Destroy(BTree* tree)
{
	BTree_Clear(tree);
	
	free(tree);
}

LinkStack.c文件

#include "LinkStack.h"
#include <assert.h>
#include <stdlib.h>

LinkStack * CreateStack()
{
	LinkStack* stack = (LinkStack*)malloc(sizeof(LinkStack)/sizeof(char));
	if (stack == NULL)
		return NULL;
	
	stack->head = NULL;  // 空栈
	
	return stack;
}

void InitStack (LinkStack *s)
{
	assert(s);
	
	s->head = NULL;
}

// 如果空返回真，否则返回假
int StackEmpty (LinkStack *s)
{
	assert (s);
	
	return s->head == NULL;
}

int Push (LinkStack *s, StackData x)
{
	assert(s);
	
	StackNode * node = (StackNode*)malloc(sizeof(StackNode)/sizeof(char));
	assert(node);
	
	node->data = x;
	node->next = s->head;
	s->head = node;
	
	return OK;
}


int Pop (LinkStack *s, StackData *x)
{
	assert (s);
	
	if (StackEmpty(s))
		return ERROR;
	
	StackNode* node = s->head;
	s->head = node->next;
	
	*x = node->data;
	free(node);
	node = NULL;
	
	return OK;
}

int GetTop (LinkStack *s, StackData *x)
{
	assert (s);
	
	if (StackEmpty(s))
		return ERROR;
	
	StackNode* node = s->head;
	*x = node->data;
	node = NULL;
	
	return OK;
}


void Destroy(LinkStack *s)
{
	assert(s);
	
	StackNode* node = s->head;
	StackNode* tmp;
	
	// 将链表的第一个结点当作头节点来使用
	while (node != NULL && node->next != NULL)
	{
		tmp = node->next;
		node->next = tmp->next;
		free(tmp);
	}
	
	// 释放第一个结点(头节点)
	free(node);
	// 释放栈结点
	free(s);
}


Btree.h文件

#ifndef __BTREE_H__
#define __BTREE_H__

#define BLEFT  0
#define BRIGHT 1

// 二叉树数据类型
typedef char BTreeData;

// 二叉树的结点
typedef struct _BtreeNode
{
	BTreeData data;
	struct _BtreeNode *lchild;  // 指向结点的左孩子的指针
	struct _BtreeNode *rchild;  // 指向结点的右孩子的指针
}BTreeNode;

typedef void (*BTree_Print)(BTreeNode*);

// 二叉树类型
typedef struct _BTree
{
	BTreeNode *root;    // 指向二叉树的根节点
	int count;          // 二叉树中结点的个数
}BTree;

BTree * Create_Btree();

// pos 是路线：110(左右右)、101(右左右)，count：走的步数
// flag：代表原来的结点要插入到新节点的位置：左或右 
int Btree_Insert(BTree* btree, BTreeData data, int pos, int count, int flag);

void DisPlay(BTree* btree, BTree_Print pfunc, int gap, char div);

int Delete(BTree* btree, int pos, int count);

BTreeNode* BTree_Get(BTree* tree, int pos, int count);

BTreeNode* BTree_Root(BTree* tree);

int BTree_Height(BTree* tree);

int BTree_Degree(BTree* tree);

int BTree_Count(BTree* tree);

void BTree_Clear(BTree* tree);

void BTree_Destroy(BTree* tree);

#endif //__BTREE_H__

LinkStack.h文件

#ifndef __LINKSTACK_H__
#define __LINKSTACK_H__

#include "BTree.h"


#define OK       0
#define ERROR   -1

typedef BTreeNode* StackData;
typedef struct _StackNode
{
	StackData data;
	struct _StackNode *next;
}StackNode;

typedef struct _LinkStack
{
	StackNode *head;
}LinkStack;

LinkStack * CreateStack();

// 置空栈
void InitStack (LinkStack *S); 		

// 判栈空否
int StackEmpty (LinkStack *S); 		

// 进栈 
int Push (LinkStack *s, StackData x);	

// 出栈
int Pop (LinkStack *S, StackData *x);

// 取栈顶 
int GetTop (LinkStack *S, StackData *x); 	

void Destroy(LinkStack *s);

#endif // __LINKSTACK_H__


LinQueue.h文件

#ifndef __LINKQUEUE_H__
#define __LINKQUEUE_H__

#include "BTree.h"

#define OK     0
#define ERROR -1

typedef BTreeNode* QueueData;
typedef struct _QueueNode
{
	QueueData data;
	struct _QueueNode *next;
}QueueNode;

typedef struct _LinkQueue
{
	QueueNode * front;    // 指向队头的指针
	QueueNode * rear;     // 指向队尾的指针
}LinkQueue;

LinkQueue * CreateQueue();

// 判队空否
int QueueEmpty (LinkQueue *Q);   

// 进队  
int EnQueue (LinkQueue *Q, QueueData x);  

// 出队 
int DeQueue (LinkQueue *Q, QueueData *x);

#endif // __LINKQUEUE_H__







小小小菜鸟丶
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现二叉树操作
06-17
本主题聚焦于使用C语言实现二叉树操作，特别是二叉搜索树。二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树，其每个节点的左子树只包含比当前节点小的元素，右子树包含比当前节点大的元素。这种特性使得...
C语言二叉树的非递归遍历实例分析
09-04
以上代码展示了C语言中非递归遍历二叉树的实现，对于先序、中序和后序遍历分别提供了详细的函数实现。这些方法在处理大型二叉树时特别有用，因为递归可能导致调用栈溢出。通过非递归方式，我们可以有效地控制内存...
二叉树的编程与实现（C语言）
timerring的博客
07-10 5万+
一 、目的： 掌握指针变量、动态变量的含义； 掌握二叉树的结构特征，以及各种存储结构的特点及适用范围； 掌握指针类型描述、访问和处理二叉树的运算三 、内容： 已知以二叉树表作为存储结构，写出按层次顺序遍历二叉树的算法。 算法思想：本算法采用一个队列q，先将二叉树根结点入队列，然后退队列，输出该结点，若它有左子树，便将左子树根结点入队列；若有右子树，便将右子树根结点入队列，直到队列空为止。因为队列的特点是先进先出，从而达到按层次顺序遍历二叉树的目的。 四 、要求： 实现二叉树表的层次遍历算法，并给出应用。
C语言实现二叉树（纯新手向）
weixin_44606789的博客
10-16 1万+
目录 一、二叉树的基本概念 二、二叉树的初始化 三、释放二叉树 四、前中后序遍历二叉树 五、主函数和效果截图 六、拓展时间 这是我这段时间学习c语言二叉树的成果，希望对大家有所帮助，共同进步！ 一、二叉树的基本概念 二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。定义结构体可以这样设计 代码
C语言二叉树的实现
小白的Coding之旅
07-24 600
BTree.h #ifndef _BTREE_H_ #define _BTREE_H_ #include<stdio.h> #include<stdlib.h> #include<string.h> typedef char BTDataType; typedef struct BinaryTreeNode { BTDataType _data; ...
C语言实现二叉树（链式）
weixin_40417029的博客
04-18 1万+
        一颗二叉树是一个节点的有限集合，是由一个根节点和两个子树构成；每个子树又有两个子树。这两个子树分为左子树和右子树，且顺序不能颠倒。如图，像一个倒着的树一样：它有两种存储方式，一种是顺序存储，一种是链式存储。顺序存储：        对于一棵完全二叉树所有结点按照层序自顶向下，同一层自左向右顺序存入一个顺序表中，如果该节点为空，则存入一个特殊的字符代表NULL。例如： 这就是二叉树的...
超全C语言二叉树基本操作及讲解
zhanggonglalala的博客
03-29 6万+
今天刷LeetCode上的题的时候，做到了关于二叉树的题，于是决定把这一块的知识整理一下。 1、二叉树的定义 二叉树通常以结构体的形式定义，如下，结构体内容包括三部分：本节点所存储的值、左孩子节点的指针、右孩子节点的指针。这里需要注意，子节点必须使用指针，就像我们定义结构体链表一样，下一个节点必须使用地址的方式存在在结构体当中。 struct TreeNode { int val;...
C语言二叉树
05-30
C语言二叉树遍历的程序，提供给大家借鉴，谢谢C语言二叉树遍历的程序，提供给大家借鉴，谢谢
C语言翻转二叉树.zip
最新发布
10-27
在C语言中，处理二叉树通常涉及创建节点、插入节点、遍历以及各种操作，如翻转二叉树。这个名为"C语言翻转二叉树.zip"的压缩包可能包含了一个实现二叉树翻转的项目，该项目可能用于教学或实践目的。 二叉树的翻转，...
C语言平衡二叉树.zip
10-27
为了完整地实现一个C语言平衡二叉树，还需要编写一个驱动程序来测试这些功能。在`isBalancedTree-master`这个项目中，可能包含了实现这些功能的源代码文件和测试用例。读者可以通过阅读这些代码来加深对平衡二叉树的...
总结的关于二叉树的所有操作（经典程序）
07-23
总结面试中出现的所有关于二叉树的操作，包括二叉树的深度优先遍历、广度优先遍历，二叉树的各种建立方式（递归和非递归都有），以及先序、中序、后序遍历的递归和非递归算法的总结。
C语言二叉树创建（一定看的懂）
TheSevenSky
06-02 8万+
  先贴一个百度出来的二叉树的图 二叉树 就是首先得有一个根节点.这个节点的入度为0也就是它只有子节点没有父节点 如1号节点     每个节点又有一个左儿子和一个右儿子 当然也可以没有 接下来就是创建.创建一棵树得现有这棵树的结点和树根     首先来声明一个树的结点   typedef struct node{ //树的结点 int data; struct no...
二叉树的常见问题及其解决程序
yangcs2009的专栏
09-29 3474
二叉树的常见问题有如下几个，如果解决好了，就跟链表一样轻松：唯一不一样的是，二叉树是非线性结构。常见的问题如下： 二叉树的问题 1.二叉树三种周游（traversal）方式： [cpp] view plaincopy 二叉树的问题  1.二叉树三种周游（traversal）方式：  2.怎样从顶部开始逐层打印二叉树结点数据  3.如何判断一棵二叉树是否是平衡二叉树 
二叉树的基本操作
热门推荐
Daioo 随笔
04-21 12万+
一、实验目的 1、掌握二叉树的定义； 2、掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度计算等。 二、实验内容 （一）用递归的方法实现以下算法： 1、以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2、输出二叉树的中序遍历结果（算法5.1）； 3、输出二叉树的前序遍历结果（见讲稿）； 4、输出二叉树的后序遍历结果（见讲稿）； 5、计算二叉树的深度（算法5.
【数据结构】计算二叉树深度完整C语言代码
九芒星的博客
07-30 2万+
二叉树深度的计算<数据结构>二叉树的深度计算完整代码展示程序结果 二叉树的深度计算 我们先看一个深度为3的二叉树。想求得此二叉树深度，先计算左孩子深度，再计算右孩子深度，比较得出最大值，即二叉树深度。 通过先序序列键盘输入一个二叉树 ABD##E##CF###。 设计算法则先遍历二叉树的左子树的深度，然后再遍历二叉树右子树的深度。最后判断左子树和右子树的深度，如果左子树比右子树深则返回左子树深度+1,否则返回右子树深度+1。 完整代码展示 #include <stdio.h> #in
C语言实现二叉树的基本操作
乞力马扎罗的雪CYF的博客
03-11 2万+
我在前面的博客中讲解了链表、栈和队列，这些数据结构其实都是线性表，并且给出了详细的实现。从今天开始，我们将要来学习树，树作为一种数据结构我们经常会用到，作为起步和基础，我们先来实现二叉树，也就是每个节点有不超过2个子节点的树。对于树的操作，最基本的创建、遍历、求树高、节点数等。代码上传至 https://github.com/chenyufeng1991/BinaryTree 。（1）节点的定义t
C语言实现二叉树排序
Future_LL的博客
01-24 2583
一、代码 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define N 10 int a[N]={3,2,5,8,4,7,6,9,1,10}; typedef struct tree { int data; struct tree *lchild; struct tree *rchild; }BitTree; void S...
二叉树的建立（C语言）
qq_34941153的博客
05-18 1万+
首先是树结点的结构 struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; }; typedef struct TreeNode TNode; typedef struct TreeNode *T_Pointer; 这没什么说的。 建树的代码： void Build_Tree(T_...
C语言二叉树的创建
jennyhwei04的博客
03-16 8114
#include   typedef struct Node {     struct Node *left;     struct Node *right;     int value; } Node;   Node* init_root(int value) {//初始化根节点的值。     Node* rr;     rr = malloc(sizeof(Node));
c语言二叉树 管理系统
09-28
C语言二叉树管理系统是一个基于C语言编写的程序，用于管理二叉树数据结构的创建、插入、删除、查找等操作。该系统提供了一系列的功能，以方便用户对二叉树进行操作和管理。 在该系统中，可以通过创建二叉树的初始化...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值