基础数据结构---顺序表（链式结构实现）

最新推荐文章于 2024-05-14 17:02:05 发布
最新推荐文章于 2024-05-14 17:02:05 发布
阅读量80 收藏
点赞数 5
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47358666/article/details/120549265
版权

文章目录

1.带头节点的单链表

在这里插入图片描述

list头文件

#pragma once
//带头节点的单链表
//头节点:不用于存储数据,只是起标记作用
//单链表:尾节点的next为空

typedef struct Node
{
	int  data;//数据域
	struct Node* next;//后继指针
}Node, * List; //List == Node *

//初始化
void InitList(List plist);

//头插
bool Insert_head(List plist, int val);

//尾插
bool Insert_tail(List plist, int val);

//插入数据,在plist顺序表的pos下标插入val
bool Insert(List plist, int pos, int val);

//判空
bool IsEmpty(List plist);

//获取数据节点个数
int GetLength(List plist);

//在plist中查找第一个key,找到返回节点地址,没有找到返回NULL
Node* Search(List plist, int key);

//删除pos位置的值
bool DelPos(List plist, int pos);

//删除第一个val值
bool DelVal(List plist, int val);

//返回key的前驱地址,如果不存在前驱则返回NULL
Node* GetPrio(List plist, int key);

//返回key的后继地址,如果不存在后继则返回NULL
Node* GetNext(List plist, int key);

//输出
void Show(List plist);

//清空数据
void Clear(List plist);

//销毁整个内存
void Destroy(List plist);

list.cpp文件

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "list.h"



//初始化
void InitList(List plist)
{
	assert(plist != NULL);
	if (plist == NULL)
		return;

	//plist->data;//头结点的data不使用
	plist->next = NULL;//单链表的尾节点next为空
}

//头插
bool Insert_head(List plist, int val)
{
	//动态申请一个新节点
	Node* p = (Node*)malloc(sizeof(Node));
	assert(p != NULL);

	//将val放到新节点
	p->data = val;

	//插入新节点
	p->next = plist->next;
	plist->next = p;

	return true;
}

//尾插
bool Insert_tail(List plist, int val)
{
	assert(plist != NULL);
	if (plist == NULL)
		return false;//exit(1);//在工作中不允许使用
	Node* p = (Node*)malloc(sizeof(Node));
	p->data = val;

	//找尾部
	Node* q;
	for (q = plist; q->next != NULL; q = q->next)
	{
		;
	}

	//插入新节点
	p->next = q->next;
	q->next = p;
	//maxsize++;这种设计不好,不要使用全局变量(不安全)
	return true;
}

//插入数据,在plist顺序表的pos下标插入val
bool Insert(List plist, int pos, int val)
{
	if (pos<0 || pos>GetLength(plist))
	{
		return false;
	}
	Node* p = (Node*)malloc(sizeof(Node));//List == Node *   不建议使用List p;
	p->data = val;

	//找位置
	Node* q;
	int i;
	for (q = plist, i = 0; i < pos; i++, q = q->next);

	//p插入在q的后面
	p->next = q->next;
	q->next = p;

	return true;
}

//判空
bool IsEmpty(List plist)
{
	return plist->next == NULL;
}

//获取数据节点个数
int GetLength(List plist)
{
	int count = 0;
	for (Node* p = plist->next; p != NULL; p = p->next)
	{
		count++;
	}

	return count;
}

//在plist中查找第一个key,找到返回节点地址,没有找到返回NULL
Node* Search(List plist, int key)
{
	for (Node* p = plist->next; p != NULL; p = p->next)
	{
		if (p->data == key)
			return p;
	}
	return NULL;
}

//删除pos位置的值
bool DelPos(List plist, int pos)
{
	if (pos < 0 || pos >= GetLength(plist))
	{
		return false;
	}

	Node* p;
	int i;
	for (p = plist, i = 0; i < pos; i++, p = p->next);

	//删除p后面的节点
	Node* q = p->next;
	p->next = q->next;
	free(q);

	return true;
}

//删除第一个val值
bool DelVal(List plist, int val)
{
	Node* p = GetPrio(plist, val);
	if (p == NULL)
		return false;
	Node* q = p->next;//将要删除的节点
	//将q从链表中剔除
	p->next = q->next;//p->next = p->next->next;

	//释放q
	free(q);

	return true;
}

//返回key的前驱地址,如果不存在前驱则返回NULL
Node* GetPrio(List plist, int key)
{
	for (Node* p = plist; p->next != NULL; p = p->next)
	{
		if (p->next->data == key)//p是前驱地址
			return p;
	}
	return NULL;
}

//返回key的后继地址,如果不存在后继则返回NULL
Node* GetNext(List plist, int key)
{
	Node* p = Search(plist, key);
	if (p == NULL)
		return NULL;
	return p->next;
}

//输出
void Show(List plist)
{
	//通过节点指针,遍历所有的数据节点(注意头结点不能访问data)
	for (Node* p = plist->next; p != NULL; p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

//清空数据
void Clear(List plist)
{
	Destroy(plist);
}

//销毁整个内存,释放所有的数据节点
void Destroy(List plist)
{
	Node* p;
	while (plist->next != NULL)//总是删除第一个数据节点
	{
		p = plist->next;
		plist->next = p->next;
		free(p);
	}
}

void Destroy1(List plist)//太复杂
{
	if (plist == NULL || plist->next == NULL)
		return;

	Node* p = plist->next;
	Node* q;
	plist->next = NULL;

	while (p != NULL)
	{
		q = p->next;
		free(p);
		p = q;
	}
}

2.带头结点的双向链表

在这里插入图片描述

dlist头文件

#pragma once
//双向链表
//带头结点的双向链表,不循环.尾节点的后继为空,头结点的前驱为空

typedef struct DNode
{
	int data;
	struct DNode* next;//后继指针
	struct DNode* prio;//前驱指针
}DNode, * DList;

//初始化
void InitList(DList plist);

//头插
bool Insert_head(DList plist, int val);

//尾插
bool Insert_tail(DList plist, int val);

//插入数据,在plist顺序表的pos下标插入val
bool Insert(DList plist, int pos, int val);

//判空
bool IsEmpty(DList plist);

//获取数据节点个数
int GetLength(DList plist);

//在plist中查找第一个key,找到返回节点地址,没有找到返回NULL
DNode* Search(DList plist, int key);

//删除pos位置的值
bool DelPos(DList plist, int pos);

//删除第一个val值
bool DelVal(DList plist, int val);

//返回key的前驱地址,如果不存在前驱则返回NULL
DNode* GetPrio(DList plist, int key);

//返回key的后继地址,如果不存在后继则返回NULL
DNode* GetNext(DList plist, int key);

//输出
void Show(DList plist);

//清空数据
void Clear(DList plist);

//销毁整个内存
void Destroy(DList plist);

dlist.cpp文件

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "dlist.h"



//初始化
void InitList(DList plist)
{
	assert(plist != NULL);
	if (plist == NULL)
		return;

	//plist->data数据域不使用
	plist->next = NULL;
	plist->prio = NULL;
}

static DNode* BuyNode(int val)
{
	DNode* p = (DNode*)malloc(sizeof(DNode));
	p->data = val;
	return p;
}

//头插
//考试的重点
bool Insert_head(DList plist, int val)
{
	//创建新节点
	DNode* p = (DNode*)malloc(sizeof(DNode));
	p->data = val;
	//DNode *p = BuyNode(val);

	//插入新节点
	p->next = plist->next;//首先将后面的数据节点绑好

	plist->next = p;
	p->prio = plist;

	if (p->next != NULL)//判断很重要
	{
		p->next->prio = p;
	}

	return true;
}

//尾插
//考试的重点
bool Insert_tail(DList plist, int val)
{
	DNode* p = (DNode*)malloc(sizeof(DNode));
	p->data = val;
	DNode* q = plist;
	//找尾巴
	for(;q->next != NULL;q = q->next)
	{
		;
	}

	//插入新节点
	p->next = q->next;
	q->next = p;
	p->prio = q;

	return true;
}

//插入数据,在plist顺序表的pos下标插入val
bool Insert(DList plist, int pos, int val)
{
	if (pos < 0 || pos > GetLength(plist))
		return false;
	DNode* q = plist;
	for (int i = 0; i < pos; i++)
	{
		q = q->next;
	}
	DNode* p = (DNode*)malloc(sizeof(DNode));
	p->data = val;

	p->next = q->next;
	q->next = p;
	p->prio = q;
	if (p->next != NULL)
	{
		p->next->prio = p;
	}

	return true;
}

//判空
bool IsEmpty(DList plist)
{
	return plist->next == NULL;
}

//获取数据节点个数
int GetLength(DList plist)
{
	int count = 0;
	for (DNode* p = plist->next; p != NULL; p = p->next)
	{
		count++;
	}

	return count;
}

//在plist中查找第一个key,找到返回节点地址,没有找到返回NULL
DNode* Search(DList plist, int key)
{
	for (DNode* p = plist->next; p != NULL; p = p->next)
	{
		if (p->data == key)
			return p;
	}
	return NULL;
}

//删除pos位置的值
bool DelPos(DList plist, int pos)
{
	if (pos < 0 || pos > GetLength(plist))
		return false;
	DNode* q = plist->next;//
	for (int i = 0; i < pos; i++)
	{
		q = q->next;
	}

	q->prio->next = q->next;
	if (q->next != NULL)
	{
		q->next->prio = q->prio;
	}

	free(q);

	return true;
}

//删除第一个val值 //考试的重点
bool DelVal(DList plist, int val)
{
	DNode* p = Search(plist, val);
	if (p == NULL)
		return false;
	//将p从链表中剔除
	p->prio->next = p->next;
	if (p->next != NULL)
	{
		p->next->prio = p->prio;
	}

	//释放节点p
	free(p);

	return true;
}

//返回key的前驱地址,如果不存在前驱则返回NULL
DNode* GetPrio(DList plist, int key)
{
	DNode* p = Search(plist, key);
	/*if(p == NULL)
		return NULL;
	return p->prio;*/
	return p == NULL ? NULL : p->prio;
}

//返回key的后继地址,如果不存在后继则返回NULL
DNode* GetNext(DList plist, int key)
{
	DNode* p = Search(plist, key);
	return p == NULL ? NULL : p->next;
}

//输出
void Show(DList plist)
{
	for (DNode* p = plist->next; p != NULL; p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

//清空数据
void Clear(DList plist)
{
	Destroy(plist);
}

//销毁整个内存
void Destroy(DList plist)
{
	/*int a = GetLength(plist);
	for (int i = 0;i< a; i++)
	{
		DelPos(plist, 0);
	}*/
	
	while (plist->next != NULL)
	{
		DelPos(plist, 0);
	}
}

3.带头结点的循环链表

在这里插入图片描述

clist头文件

#pragma once
//循环链表:尾部节点的next指向头结点,形成一个环形
//带头结点

typedef struct CNode
{
	int data;
	struct CNode* next;
}CNode, * CList;

//初始化
void InitList(CList plist);

//头插
bool Insert_head(CList plist, int val);

//尾插
bool Insert_tail(CList plist, int val);

//插入数据,在plist顺序表的pos下标插入val
bool Insert(CList plist, int pos, int val);

//判空
bool IsEmpty(CList plist);

//获取数据节点个数
int GetLength(CList plist);

//在plist中查找第一个key,找到返回节点地址,没有找到返回NULL
CNode* Search(CList plist, int key);

//删除pos位置的值
bool DelPos(CList plist, int pos);

//删除第一个val值
bool DelVal(CList plist, int val);

//返回key的前驱地址,如果不存在前驱则返回NULL
CNode* GetPrio(CList plist, int key);

//返回key的后继地址,如果不存在后继则返回NULL
CNode* GetNext(CList plist, int key);

//输出
void Show(CList plist);

//清空数据
void Clear(CList plist);

//销毁整个内存
void Destroy(CList plist);

clist.cpp文件

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "clist.h"

//初始化
void InitList(CList plist)
{
	assert(plist != NULL);
	if (plist == NULL)
		return;

	plist->next = plist;//环形
}

//头插
bool Insert_head(CList plist, int val)
{
	CNode* p = (CNode*)malloc(sizeof(CNode));
	assert(p != NULL);
	if (p == NULL)
		return false;
	p->data = val;

	//头插
	//CNode* q = plist;
	p->next = plist->next;
	plist->next = p;

	return true;

}

//尾插
bool Insert_tail(CList plist, int val)
{
	//创建新节点
	CNode* p = (CNode*)malloc(sizeof(CNode));
	assert(p != NULL);//以前要判断,现在一般不判断
	if (p == NULL)
		return false;
	p->data = val;

	//找尾巴
	CNode* q;
	for (q = plist; q->next != plist; q = q->next);

	//插入新节点,p插入在q的后面
	p->next = q->next;//p->next = plist;
	q->next = p;

	return true;
}

//插入数据,在plist顺序表的pos下标插入val
bool Insert(CList plist, int pos, int val)
{
	if (pos < 0 || pos > GetLength(plist))
		return false;
	CNode* q = plist;
	for (int i = 0; i < pos; i++)
	{
		q = q->next;
	}
	CNode* p = (CNode *)malloc(sizeof(CNode));
	p->data = val;
	p->next = q->next;
	q->next = p;
	return true;
}

//判空
bool IsEmpty(CList plist)
{
	return plist->next == plist;
}

//获取数据节点个数
int GetLength(CList plist)
{
	
	int count = 0;
	for (CNode* p = plist->next; p != plist; p = p->next)
	{
		count++;
	}

	return count;
}

//在plist中查找第一个key,找到返回节点地址,没有找到返回NULL
CNode* Search(CList plist, int key)
{
	assert(plist != NULL);
	
	for (CNode* q = plist->next; q->next != plist;q = q->next)
	{
		if (q->data == key)
			return q;
	}
	return NULL;
}

//删除pos位置的值
bool DelPos(CList plist, int pos)
{
	if (pos < 0 || pos > GetLength(plist))
		return false;
	CNode* q = plist;
	for (int i = 0; i < pos - 1; i++)
	{
		q = q->next;
	}
	CNode* p = q->next;
	q->next = p->next;
	free(p);
	return true;
}

//删除第一个val值
bool DelVal(CList plist, int val)
{
	CNode* p = GetPrio(plist, val);
	if (p == NULL)
		return false;
	CNode* q = p->next;//将要删除的节点
	//将q从链表中剔除
	p->next = q->next;//p->next = p->next->next;

	//释放q
	free(q);

	return true;
}

//返回key的前驱地址,如果不存在前驱则返回NULL
CNode* GetPrio(CList plist, int key)
{
	assert(plist != NULL);
	for (CNode* q = plist->next; q->next != plist; q = q->next)
	{
		if (q->next->data == key)
			return q;
	}
	return NULL;
}

//返回key的后继地址,如果不存在后继则返回NULL
CNode* GetNext(CList plist, int key)
{
	assert(plist != NULL);
	for (CNode* q = plist->next; q->next != plist; q = q->next)
	{
		if (q->data == key)
			return q->next;
	}
	return NULL;
}

//输出
void Show(CList plist)
{
	for (CNode* p = plist->next; p != plist; p = p->next)
	{
		printf("%d ", p->data);
	}
	printf("\n");
}

//清空数据
void Clear(CList plist)
{
	Destroy(plist);
}

//销毁整个内存
void Destroy(CList plist)
{
	CNode* p;
	while (plist->next != plist)//总是删除第一个数据节点
	{
		p = plist->next;
		plist->next = p->next;
		free(p);
	}
}
__小柒
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
# 数据结构-顺序表和链式表
05-23
数据结构-顺序表和链式表 VS2013 C++实现
php数据结构之顺序链表与链式线性表示例
10-18
主要介绍了php数据结构之顺序链表与链式线性表,结合实例形式较为详细的分析了php实现顺序链表与链式线性表的各种常用操作技巧,需要的朋友可以参考下
数据结构-顺序表基本功能的实现
qq_61167424的博客
03-23 2624
详细的基本功能实现（顺序表其实一点也不难）
数据结构-顺序表
2302_79539362的博客
11-27 2351
数据结构-顺序表
数据结构-线性表的顺序、链式存储结构
qq_61167424的博客
03-21 4265
一篇文章带你了解线性表的顺序、链式存储结构
数据结构 - 顺序表基本操作
qq_61386381的博客
05-07 2090
前言： 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组 上完成数据的增删查改。 顺序表一般可以分为：..
数据结构-链式结构
wooovi的博客
02-05 2557
数据结构-链式结构线性表的链式表示及实现链式存储结构与链式存储有关的术语链表（链式存储结构）的特点单链表的定义与表示单链表基本操作的实现单链表的初始化（带头结点的单链表），即构造一个空的单链表（补充）判断链表是否为空(补充)单链表的销毁：销毁链表后不存在（补充）清空链表（补充）求单链表长单链表取值-取第i个元素单链表查值单链表插入单链表中删除元素--删除第i个结点单链表的建立-头插法单链表的建立-尾插法 线性表的链式表示及实现 链式存储结构 节点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定
数据结构 - 链式队列
weixin_49303682的博客
12-26 2628
1.链式队列 链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储 区和指针存储区。 数据存储区 ：存放真实有效数据的区域。 指针存储区 ：存放下一个链表结点的地址。 2.创建链式队列 为链式队列申请内存，即为队首指针和队尾指针申请内存。 为链式队列头结点申请内存，头结点不存放有效数据，方便队列的操作。 将队首指针和队尾指针指向头结点，即队首指针和队尾指针相等。 链式队列头结点指针域为空，即为NULL；头结点数据域可不管，亦可为零，作为链式队列有效的
数据结构-链式二叉树
m0_61433144的博客
08-02 2163
对于那些非完全二叉树，由于顺序存储结构的空间利用率低，因此二叉树一般都采用链式存储结构，用链表结点来存储二叉树中的每一个结点。在链式二叉树中，结点结构通常包括数据域和若干个指针域。......
数据结构-用C语言实现链式栈
小鬼哥是大王
12-19 1220
堆栈的基本概念 堆栈是只能在一端增删元素的表结构，该位置称为栈顶 堆栈的基本运算是压入和弹出，前者相当于插入，而后者则是删除最后插入的元素，形成后进先出的运算规则 最后插入的元素在被弹出之前可以作为栈顶被外界访问 从空栈中弹出，或向满栈中压入，都被认为是一种错误 常见的栈有顺序栈和链式栈 顺序栈 链式栈 - 链式栈的C代码实现 #include <stdio.h> #include <stdlib.h> /*节点的结构*/ typedef struct node {
数据结构-线性表的链式存储（包含代码实现）
qq_46338854的博客
05-05 7550
线性表的链式表示和实现 链式存储结构 结点在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理上不一定相邻 线性表的链式存储结构又称为非顺序映像或链式映像。 用一组物理位置任意的存储单元来存放线性表的数据元素 这组存储单元既可以是连续的，也可以是不连续的，甚至是零散分布在内存中的任意位置上的。 链表中元素的逻辑次序和物理次序不一定相同 与链式存储结构相关的术语 1、结点：数据元素的存储映像。由数据域和指针域两部分组成 数据域：存放元素数值数据 指针域：存放直接后继结点的存储位置 2、链表：n个结点
数据结构-链表（含全部实现代码）
qq_45967533的博客
03-12 7082
本篇的内容是对链表的一个介绍，并且会使用C语言实现链表的几个主要接口。 目录链表的概念与结构 链表的概念与结构 概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 一个链表由n个节点组成，每一个节点都是一个结构体，这个结构体里的一个成员是该节点存储的数据，另一个成员是指向下一个节点的指针。 其结构如下 上图只是一种结构的链表，并不是所有的链表都是这样的结构，在实际中链表的结构非常多样，有以下几种情况：是否带头，单向还是双向，是否循环。共23=8种
数据结构-顺序表实现.doc
07-11
熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现。 三、实验原理： 线性表是最常用的而且也是最简单的一种数据结构，线性表是N个数据元素的有限序列 。例如26个英文元素的字母表：（A，B，C，D，·...
数据结构：顺序表（链式存储）
12-07
使用c实现数据结构中的顺序表（链式存储）： 功能： 1、头节点的创建 2、判断链表是否是 空\满 3、计算链表节点个数 4、插入节点（按 下标\元素） 5、删除节点（按 下标\元素） 6、按元素查询下标 7、打印链表 8、...
数据结构顺序表的实现方式.docx
11-26
数据结构顺序表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是...
数据结构（python）之小杨笔记一
m0_74811962的博客
05-10 351
数据结构：数据结构是计算机科学中研究数据组织、管理和存储方式的一门重要领域。（5.）树：一种非线性的数据结构，由节点和边组成，每个节点最多有一个夫节点和多个子节点。（2.）链表：由一系列节点组成的数据结构，每个结构包含数据和指向下一个节点的指针。（3.）图的算法：用于解决图结构中的各种问题的算法，如最短路径，最小生成树。的数据结构，只能在队列的前端进行删除操作，在队列的后端进行插入操作。（6.）图：一种包含节点和边的数据结构，用于表示对象之间的关系。（1.）堆：一种特殊的树形数据结构，用于实现。
Go解析的数据类型可能含有不同数据结构的处理方式
最新发布
不主动，不拒绝，不负责
05-14 173
最近做一个需求，各种业务消息都会往我的消息队列中写各种类型的数据，服务端需要接受各种不同的参数然后转换为本地数据结构，Go语言不确定上游传过来的数值是什么类型，然后又下面四种解决方案。
【数据结构】线性表----链表详解
Skrrapper的博客
05-14 990
前面我们介绍的顺序表，在逻辑结构和物理结构上都是线性、连续的关系，那么我们在篇尾的时候也提到了是否有一种顺序表，无需在物理结构上连续，从而达到更好存取的目的呢？今天它来了。链表（LinkList）属于线性表的一种，以下是百度百科关于链表的定义：在结构上链表数据域指针域。我们可以类比成火车，火车每一节车厢实际上是独立的，也就好比数据域，存储着各自的数据；但每一节车厢之间都会由一条链连接在一起，从而形成整个火车，链也就好比指针域，起到连接该车厢和指向下一车厢的作用。而实际上这样的存储结构也就是为什么。
【数据结构】链表
小林的博客
05-12 338
​ 链表不同于顺序表，顺序表底层采用数组作为存储容器，需要分配一块连续且完整的内存空间进行使用，而链表不需要，它通过一个指针来连接各个分散的结点，形成了一个链状的结构，每个结点存放一个元素，以及一个指向下一个结点的指针，通过这样一个一个相连，最后形成了链表。​ 它不需要申请连续的空间，只需要按顺序连接即可，虽然物理上可能不想邻，但在逻辑上依然是每个元素相邻存放的，这种结构就叫链表（单链表）
数据结构--链式存储结构
10-19
引用中则介绍了数据结构中的线性结构和线性表的顺序表示和实现，以及顺序表的案例，这些内容可以帮助更好地理解链式存储结构与其他存储结构的区别和联系。引用则强调了链表中元素的逻辑次序与物理次序不一定相同，这...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

__小柒

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

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

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

打赏作者

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

抵扣说明：

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

余额充值