二叉树的实现-c

最新推荐文章于 2023-11-12 16:47:11 发布
最新推荐文章于 2023-11-12 16:47:11 发布
阅读量226 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dingyuan0/article/details/124997041
版权

1.二叉树概况方向：

在这里我先推荐几道关于二叉树的基础OJ题，加快友友们实现。
链接: 基础OJ题

typedef char BTDataType;
 
typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;
 
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);

2.分析与解刨

1.二叉树的销毁，我建议用一级指针，保持与其它的一致（到外面把根置空。），当然也可以用二级的。
2.判断是应该用bool,但是本质就是0是错，1是对，我们可以打印来观看。

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);

在这里插入图片描述

在先序遍历的过程中构建每一个节点
解析图
代码：

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树


BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	//当结点没有孩子或这走到最后都要返回NULL
	if (a[*pi]=='#' || (*pi) >= n)
	{
		++(*pi);
		return NULL;
	}

	
	//创建一个结点
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
	if (root == NULL)
	{
		printf("malloc  file!");
		exit(-1);
	}

	root->data = a[(*pi)++];
	root->left = BinaryTreeCreate(a, n, pi);
	root->right= BinaryTreeCreate(a, n, pi);
	
	return root;
}

运行结果：
红框是前序遍历，后面两个是中和后序遍历
红框是前序遍历，后面两个是中和后序遍历
推荐一道题：链接: 二叉树遍历
题解解析：

/*
解题思路：
在先序遍历的过程中构建每一个节点
*/
#include <stdio.h>
#include <malloc.h>
 
typedef struct BTNode
{
    char _data;
    struct BTNode* _left;
    struct BTNode* _right;
}BTNode;
 
//中序遍历
void Inorder(BTNode* root)
{
    if(root)
    {
        Inorder(root->_left);
        printf("%c ", root->_data);
        Inorder(root->_right);
    }
}
 
BTNode* CreatBTree(char* str, int* pi)
{
    if(str[*pi]!= '#')
    {
        //当前节点非空，则创建当前节点
        BTNode*root=(BTNode*)malloc(sizeof(BTNode));
        root->_data = str[*pi];
        //字符位置向后移动一个位置
        ++(*pi);
        //创建左子树
        root->_left=CreatBTree(str,pi);
        //字符位置向后移动一个位置
        ++(*pi);
        //创建右子树
        root->_right=CreatBTree(str,pi);
        return root;
    }
    else
        return NULL;  //如果是空节点，则返回NULL
}
 
int main()
{
    char str[101];
    int i = 0;
    //读入字符串
    scanf("%s", str);
    //创建二叉树
    BTNode* root = CreatBTree(str, &i);
    //中序打印二叉树
    Inorder(root);
    printf("\n");
    return 0;
}

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在
层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层
上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
层序遍历解析图

层序遍历的思路：我们需要借助队列来实现，c语言只能自己来实现一个。链接: 队列
我们有了一个队列后(当然我们队列里存的是结点)，我们可以先存一个树的根，然后取出的时候再放它的孩子，当然它孩子为空不存，只取。例如：存了A，当我们存它的孩子B、C的时候先利用队列的性质把A取出来（打印一下）后存BC。依次类推。
解析图
在这里插入图片描述
在这里插入图片描述
代码：

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}

	//如果队列不为空，进入。
	while (!QueueEmpty(&q))
	{
		//取出 打印 
		BTNode* front = QueueFront(&q);
		printf("%c ", front->data);
		QueuePop(&q);

		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		if (front->right)
		{
			QueuePush(&q, front->right);
		}

	}

	printf("\n");
	//销毁队列
	QueueDestroy(&q);
}

运行结果：
A B C D E F G H

// 二叉树销毁
void BinaryTreeDestory(BTNode** root);

我建议使用一级，不用二级所以就，销毁我采用的是后序的方法来销毁。
代码段：

// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
		return;

	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	//printf("%p %c\n", root, root->data);
	free(root);

}

通过打印看销毁成功
在这里插入图片描述

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);

层序遍历遇到NULL，不把这个结点放进去，而判断完全二叉树先把NULL存进去，当拿出的那个结点为空；我们跳出来后；此时只有两种情况。（1.如果后面全是空，则是完全二叉树；2.如果后面还有非空，则不是完全二叉树。）

代码段：

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
			//遇到NULL，跳出。
			break;
		}

	}

	//1.如果后面全是空，则是完全二叉树；
	//2.如果后面还有非空，则不是完全二叉树。
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front)
		{
			QueueDestroy(&q);
			return false;
		}

	}

	QueueDestroy(&q);
	return true;
}

结果展示：
0为假1为真
1、前序遍历的数组"ABD##E#H##CF##G##"构建二叉树，它不是完全二叉树，而"ABD##E##CF##G##"是完全二叉树。
1.在这里插入图片描述
2在这里插入图片描述
显然第二个是完全二叉树

总的代码：

在这里插入图片描述

两个.h文件

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<string.h>


typedef char BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;


// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
// 二叉树销毁
void BinaryTreeDestory(BTNode* root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);


#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

//前置声明
struct BinaryTreeNode;

typedef struct BinaryTreeNode* QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct
{
	QNode* head;
	QNode* tail;
}Queue;

//初始化
void QueueInit(Queue* pq);

//销毁
void QueueDestroy(Queue* pq);

//放数据
void QueuePush(Queue* pq, QDataType x);

//删除
void QueuePop(Queue* pq);

//长度
int QueueSize(Queue* pq);

//取头
QDataType QueueFront(Queue* pq);

//取尾
QDataType QueueBack(Queue* pq);

//判断空
bool QueueEmpty(Queue* pq);

3个.c文件

#include"bt.h"
#include"queue.h"

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树


BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
	//当结点没有孩子或这走到最后都要返回NULL
	if (a[*pi]=='#' || (*pi) >= n)
	{
		++(*pi);
		return NULL;
	}

	
	//创建一个结点
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
	if (root == NULL)
	{
		printf("malloc  file!");
		exit(-1);
	}

	root->data = a[(*pi)++];
	root->left = BinaryTreeCreate(a, n, pi);
	root->right= BinaryTreeCreate(a, n, pi);
	
	return root;
}

// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
		return;

	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	//printf("%p %c\n", root, root->data);
	free(root);

}

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
		return 0;

	return 1 + BinaryTreeSize(root->left) + BinaryTreeSize(root->right);
}

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;

	if (root->left == NULL && root->right)
		return 1;

	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	assert(k >= 1);
	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;

	
	BTNode* ret1 = BinaryTreeFind(root->left, x);
	if (ret1)
		return ret1;

	BTNode* ret2 = BinaryTreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}

// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
		return;

	printf("%c ", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
}

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
		return;

	BinaryTreePrevOrder(root->left);
	printf("%c ", root->data);
	BinaryTreePrevOrder(root->right);
}

// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
		return;

	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
	printf("%c ", root->data);
}

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}

	//如果队列不为空，进入。
	while (!QueueEmpty(&q))
	{
		//取出 打印 
		BTNode* front = QueueFront(&q);
		printf("%c ", front->data);
		QueuePop(&q);

		if (front->left)
		{
			QueuePush(&q, front->left);
		}
		if (front->right)
		{
			QueuePush(&q, front->right);
		}

	}

	printf("\n");
	//销毁队列
	QueueDestroy(&q);
}

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
			//遇到NULL，跳出。
			break;
		}

	}

	//1.如果后面全是空，则是完全二叉树；
	//2.如果后面还有非空，则不是完全二叉树。
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front)
		{
			QueueDestroy(&q);
			return false;
		}

	}

	QueueDestroy(&q);
	return true;
}

#include"queue.h"

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

//销毁
void QueueDestroy(Queue* pq)
{

	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;

}

//放数据
void QueuePush(Queue* pq, QDataType x)
{

	assert(pq);
	//开辟空间
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	//添加数据
	newnode->data = x;
	newnode->next = NULL;

	//链接
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

}

//判断空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

//删除
void QueuePop(Queue* pq)
{

	assert(pq);
	assert(!QueueEmpty(pq));

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

}


//取头
QDataType QueueFront(Queue* pq)
{

	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

//取尾
QDataType QueueBack(Queue* pq)
{

	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

//长度
int QueueSize(Queue* pq)
{

	assert(pq);

	QNode* cur = pq->head;
	int count = 0;
	while (cur)
	{
		++count;
		cur = cur->next;
	}

	return count;
}


#include"bt.h"
#include"queue.h"

int main()
{
    char ch[] = "ABD##E#H##CF##G##";
    //gets(ch);
    int n = strlen(ch);
    int i = 0;
    //BinaryTreeCreate
    BTNode* root = BinaryTreeCreate(ch, n, &i);
    //进行前序遍历，输出遍历结果。
    BinaryTreePrevOrder(root);
    printf("\n");
    //进行中序遍历，输出遍历结果。
    BinaryTreeInOrder(root);
    printf("\n");
    //进行后序遍历，输出遍历结果。
    BinaryTreePostOrder(root);
    printf("\n");
    //结点个数
    int ret = BinaryTreeSize(root);
    printf("%d\n", ret);
    //叶结点的个数
    int ret1 = BinaryTreeLeafSize(root);
    printf("%d\n", ret1);
    //第k个结点
    int ret2 = BinaryTreeLevelKSize(root, 2);
    printf("%d\n", ret2);

    //借用队列实现层序遍历
    BinaryTreeLevelOrder(root);

    // 判断二叉树是否是完全二叉树
    int ret3 = BinaryTreeComplete(root);
    printf("%d\n", ret3);

    BTNode* c = BinaryTreeFind(root, ch[2]);
    printf("%c", c->data);

    BinaryTreeDestory(root);
    root = NULL;
    return 0;
}

看完之后，二叉树的基本友友们已经掌握了，下个文章见.

昨天；明天。今天。
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
二叉树-基于C语言实现的二叉树基本操作.zip
04-26
二叉树 二叉树_基于C语言实现的二叉树基本操作
二叉树的实现（C语言）
m0_70403090的博客
09-11 2319
如果数组a【*pi】不为空，就开辟空间来存储a【*pi】，同时（*pi）++。然后依次根据左子树，右子树来递归建立树，遇到空时返回。只有遇到叶子节点的时候才会返回1，这样左右子树层层返回相加，最后计算出叶子节点个数。用lh和rh来比较大小，这样更深一层的树就会显示出来，包含了浅一层的树。也是依次层序遍历，然后在最后一层判断遇到空后是不是一直为空。由于树是链表结构，所以用递归来依次释放节点。二叉树是采用链表的结构来实现。在访问左右子树前先打印该节点。依然采用递归来计算节点个数。其中包含了队列的使用方式。
【数据结构】二叉树——链式结构的实现（代码演示）
weixin_53269843的博客
05-29 1921
主要内容包括：二叉树的创建、二叉树的销毁、二叉树的遍历（前序、中序、后续、层序）、 二叉树的节点个数、二叉树的叶子节点个数、二叉树的深度、以及代码演示
【数据结构】二叉树的实现
m0_73367097的博客
05-13 1516
二叉树的实现
C语言实现二叉树（初阶数据结构）
qq_58724706的博客
01-01 3014
树的概念及结构 树的概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点。 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的。 ...
数据结构—二叉树的模拟实现（c语言）
weixin_55582891的博客
11-12 443
详解—数据结构《树和二叉树》-CSDN博客上一节课我们详解了树和二叉树，这一篇博客我来带领大家来模拟实现二叉树。
C语言实现二叉树（纯新手向）
weixin_44606789的博客
10-16 1万+
目录 一、二叉树的基本概念 二、二叉树的初始化 三、释放二叉树 四、前中后序遍历二叉树 五、主函数和效果截图 六、拓展时间 这是我这段时间学习c语言二叉树的成果，希望对大家有所帮助，共同进步！ 一、二叉树的基本概念 二叉树（binary tree）是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。定义结构体可以这样设计 代码
二叉树的实现（C语言数据结构）
芊樱烛渊的博客
05-23 9303
一、以下是我们需要实现的功能 #pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <stdbool.h> typedef char BTDataType; typedef struct BinaryTreeNode { BTDataType _data; struct BinaryTreeNode* _left; stru
深入理解二叉树（超详细）
Kalton的博客
09-17 1万+
二叉树（Binary Tree） 回顾 在前面的文章 — 二叉树前奏中，我们对于二叉树的一些基本概念进行了回顾，同时对比了线性结构与树形结构，总结了一些常见的二叉树的性质，像二叉树，真二叉树，完全二叉树，以及满二叉树等等，但是，我们仅仅是在概念上对于二叉树有所了解，并没有进行编码工作，今天来完善一下这一步的操作 直接进入二叉树的设计与编码，如果你对于二叉树的概念以及性质不了解的话，可以回去翻翻 二叉树前奏，熟悉一下，因为编码实际上就是对于二叉树性质的一个体现 设计 属性与节点 首先，我们的二叉树是用来存放元
二叉树实现（C语言完整代码+详细注释版）【数据结构】
小賀のBlog
08-16 1万+
注释详细完整且健壮的二叉树的顺序/链式以及线索二叉树实现与常规操作的代码： 二叉树的顺序实现 // // main.c // SqBiTree // // Created by Eason on 2020/8/7. // Copyright © 2020 Eason. All rights reserved. // #include <stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #defin
【数据结构】——二叉树详解
热门推荐
atwdy的博客
07-28 4万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
二叉树-基于Objective-C的完全二叉树实现的优先队列.zip
04-26
二叉树 二叉树_基于Objective-C的完全二叉树实现的优先队列
数据结构之线索二叉树-C语言实现.pdf
01-15
线索二叉树 数据结构学习笔记——线索二叉树
二叉树-基于C语言实现的二叉树动态可视化打印.zip
04-26
二叉树 二叉树_基于C语言实现的二叉树动态可视化打印
数据结构第五章-树与二叉树 二叉树的C语言实现代码
最新发布
05-22
该资源中为【数据结构】专栏——C语言实现二叉树篇章中涉及到的代码 代码中包含以下内容： 1. 二叉树相关头文件： - 二叉链表的数据类型声明 - 链队列结点类型声明 - 链队列类型声明 - 二叉树基本功能（二叉树的...
【数据结构】二叉树（C语言实现）
在平淡的日子里寻找存在的价值
08-15 6142
树和二叉树的基本介绍，以及基于C语言的链式二叉树的实现。
二叉树（详解）
weixin_63246738的博客
03-30 1万+
简单实现二叉树
【数据结构】链式二叉树【递归】
kdjjdjdjjejje128的博客
08-27 602
链式二叉树
C语言算法基础——二叉树的实现
weixin_52109967的博客
07-26 3547
菜鸟日常学习算法的总结！
二叉树实现代码c语言
11-25
二叉树是一种非常常用的数据结构，它的实现代码在C语言中也是比较简单的。下面我用300字中文回答怎样在C语言中实现二叉树的代码。 首先，我们需要定义二叉树的结构体。一个二叉树的结点包含一个数据域和两个指针域...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

昨天；明天。今天。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值