关于链表，看这一篇就够了！（新手入门）

最新推荐文章于 2024-04-27 12:39:09 发布
最新推荐文章于 2024-04-27 12:39:09 发布
阅读量7.5w 收藏 3.2k
点赞数 636
分类专栏： 数据结构 文章标签： 链表 指针 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52532896/article/details/115831698
版权

链表是一种物理存储单元上非连续、非顺序的存储结构。数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

线性表的顺序存储结构缺点是每一次插入和删除元素，大量元素的移动会导致时间效率低下。为了改进顺序存储结构的缺点，引入链式存储结构，即为链表。

链式存储结构的特点是用一组任意的存储单元来存储线性表中的数据元素。这样在插入和删除元素时，可以通过直接修改指针完成操作，时间效率大大提高。但因为链式存储结构的存储单元不连续，所以需要通过指针来访问它的后续元素。

为了表示每个数据元素与其直接后继数据元素之间的逻辑关系，我们需要存出一个其直接后继的存储位置。我们把存储数据元素信息的域成为数据域，把存储后继位置的域称为指针域，这两部分构成一个节点。

n个节点链接成一个链表，即为线性表的链式存储结构。因为每个节点只有一个指针域，所以又将这样的链表称为单链表。

下面介绍单链表的几种基本操作：

单链表的基本操作

链表的创建

链表的一个节点由指针域和数据域构成。

链表的整体思想其实并不难懂，但一旦让他和指针结合在一起时，就容易让人摸不得头脑。

可以这样理解：在链表的创建中，添加一个指向下一个节点的指针，这个指针保存的是下一个节点的地址，我们说这个指针指向下一个节点。

那么指针的类型是什么呢？当然是Node了，因为指针不仅仅指向数据域，同时也指向指针域。

下面引入一段话来帮助理解：

将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过来说，指针中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。

代码实现：

struct Node{
    ElemType data;
    struct Node *next;
};

链表的初始化

  1. 参数的传入：涉及改变链表的操作统统用指针传链表，不然函数调用完成之后，为传入的链表分配的的内存会自动释放，链表不会有任何改变。
  2. 创建头结点，为头结点分配内存。
  3. 令头节点的指针为空指针(指针不初始化容易出现很多问题)

PS：这里为什么要动态分配内存呢？

因为这就是数组和链表的区别呀：线性表的顺序存储结构用数组实现，而数组占用的是一整块内存，数组元素分布很集中，需要提前预定数组的长度。

而链表是一种动态结构，它所占用的大小和位置是不需要提前分配的，可以根据自身的需求即时生成。

代码实现：

void InitList(LinkList *L){
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;
}

判断链表是否为空

如果链表头结点指针域不为空，证明链表不为空。反之链表为空。（因为头结点指针域存储的就是链表的第一个元素的地址）

bool EmptyList(LinkList L){
	if(L->next)
		return false;
	else
		return true;
}

返回链表元素个数

因为链表中没有定义表长，所以要用到“工作指针后移”的思想，就是从第一个节点指针开始依次后移，直到节点为空为止，这时循环执行的的次数就是表长。

  1. 声明一个节点指针 p 指向链表的第一个节点。
  2. 当 p 不为空时，使指针 p 不断后移。
  3. 用 i 计数，循环结束后返回。

代码实现：

int LengthList(LinkList L){
	int i = 0;
	LinkList p = L->next;
	//L是头结点，L->next 代表链表的第一个节点。
	//LinkList其实是 Node * ，所以p指向链表的链表的第一个节点。
	while(p){
		i++;
		p = p->next;
	}
	//指针一直后移，直到节点不存在为止。
	return i;
}

清空链表

这里仍然用到了“工作指针后移”的思想，从第一个节点开始，每一个节点依次释放内存，直到最后一个节点停止。

  1. 声明节点q，p。
  2. 将第一个节点赋值给p。
  3. 将下一个节点赋值给q，释放q，将q赋值给q。
  4. 往复循环，直到全部节点的内存释放完成。

代码实现：

void ClearList(LinkList *L){
	LinkList p,q;
	p = (*L)->next;
	while(p){
		q = p->next;
		free(p);
		p = q;
	}
	(*L)->next = NULL;
}

思考：while循环里的值能不能为：

free(p);
p = p->next;

答：肯定会出错。

因为这里的free释放的是 p 整个节点，指针域也会消失。指针域消失后运行第二行代码时会报错。

返回给定位置的元素值

节点指针从第一个节点开始后移，直到指针移动到到指定位置时，若节点不为空，直接返回其值。

  1. 创建一个节点指针p指向链表的第一个节点，初始化cnt从1开始
    （为什么从1开始，因为位置最小是1）
  2. 当 cnt < i 时，遍历链表，使p的指针不断后移
  3. 当 cnt = i 时，返回该节点数据域的值。
  4. 如果链表末尾p为空，则说明第i个元素不存在

代码实现：

Status(LinkList L,int i,Elemtype *e){
	int cnt = 1;
	LinkList p = L->next;
	while(p && cnt < i){
		p = p->next;
		cnt++; 
	}
	if(!p)
		return ERROR;
	*e = p->data;
	return OK;
}

查找数据

结合“工作指针后移”的思想，以下的代码应该不难理解。

  1. 声明一个节点 p 指向链表的第一个节点，初始化 i 从0开始。
  2. 依次对每一个 p 节点的指针域与 e 进行对比，相等则返回对应值，不相等则返回0。
  3. 当 p 不为空时，使 p 指针不断后移。

代码实现：

int LocateList(LinkList L,Elemtype *e){
	int i = 0;
	LinkList p = L->next;
	
	while(p){
		i++;
		if(p->data == e)
			return i;
			
		p = p->next;	
	}
	return 0;
}

删除元素

节点指针依次后移，到指定位置后，如果节点不为空，返回其数据域。释放该节点前，要将前一个节点的指针指向该删除节点的后继元素。

  1. 声明一节点 p 指向链表的头结点，初始化 cnt 为 1。
  2. 当 cnt 小于 i 时，遍历链表，然p的指针不断后移，不断指向下一个节点，cnt 逐次加1。
  3. 如果链表末尾 p 不存在，说明要查找的元素不存在。
  4. 将要删除的节点赋值给 q。
  5. 将 q 的后继赋值给 p 的后继。
  6. 返回 q 的数据域给 e。
  7. 系统回收 q 节点，释放q的内存。

代码实现：

Status ListDelete(LinkList *L,int i,ElemType *e){
	int cnt = 1;
	LinkList q,p;
	p = (*L);
	//此时 p 为头节点，p->next为第一个节点，对应cnt的值为1。
	while( p->next && cnt < i){
		p = p->next;
		cnt++;
	}
	//第一个节点不为空，并且 cnt 小于要删除的节点位置，开始循环 
	if(!(p->next))
		return ERROR;
	//与上方呼应，p->next是要删除的元素，也就是下文的q。
	q = p->next;
	p->next = q->next;  //将p节点的指针指向q的下一个节点
	*e = q->data;  //保留要删除节点的数据域
	free(q);
	return OK;
}

插入元素

插入操作的思路和删除有点类似，大体步骤为找到要插入的位置，创建新节点，使前一个节点的指针指向新节点，使新节点的指针指向原节点后面的节点。

  1. 声明一节点 p 指向链表的头结点，初始化 cnt 为 1。
  2. 当 cnt 小于 i 时，遍历链表，然p的指针不断后移，不断指向下一个节点，cnt 逐次加1。
  3. 如果链表末尾 p 不存在，说明插入位置有误。
  4. 查找成功就创建新节点 s ，并为 s 节点分配内存。
  5. 将要插入的元素的值 e 赋值给s->data。
  6. 将 p 节点的指针域赋值给 s 节点的指针域（使两者的后继元素相同）。
  7. 使 p 节点的指针指向 s 。

代码实现：

Status ListInsert(LinkList *L,int i,ElemType e){
	LinkList p,s;
	p = (*L);
	int cnt = 1;
	while(p && cnt < i){
		cnt++;
		p = p->next;
	}
	if(!p)
		return ERROR;
	s = (LinkList)malloc(sizeof(Node));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}

随机数：

在讲下面的两个操作之前，先说明一下如何产生随机数：

随机数的产生与两个函数相关：srand函数和rand函数，两者配合使用可以产生伪随机数序列。头文件为：<stdlib. h>。

rand函数：

rand函数在产生随机数前，需要系统提供的生成伪随机数序列的种子，rand根据这个种子的值产生一系列随机数。如果系统提供的种子没有变化，每次调用rand函数生成的伪随机数序列都是一样的。

srand函数：

srand()通过参数seed改变系统提供的种子值，从而可以使得每次调用rand函数生成的伪随机数序列不同，从而实现真正意义上的“随机”。

生成随机数序列的方法：

通常可以利用系统时间来改变系统的种子值，即srand(time(NULL))，可以为rand函数提供不同的种子值，进而产生不同的随机数序列。

示例：

#include<stdlib.h>//头文件包含rand和srand函数
#include<stdio.h>
#include<time.h>
 
int main(){
	srand(time(0));//选取种子文件
	int k;
	
	for(int i = 0; i < 20; i++){
 	 	k = rand() % 101;  //输出0-100之间的随机数
 	 	printf("k = %d\n",k);
}
	return 0;
}

建立有头结点的单链表（头插法）

  1. 声明一指针节点 p
  2. 初始化随机数种子
  3. 建立一个带头结点的链表
  4. 在循环里执行如下操作：生成新节点 p，为新节点 p 的数据域随机赋值，将 p 插入到表头，执行 n 次

代码实现：

void CreateListHead(LinkList *L,int n){
	LinkList p;
	srand(time(0));
	//初始化随机数种子
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;
	//初始化链表
	for(int i = 0 ; i < n ; i++){
		p = (LinkList)malloc(sizeof(Node));  //建立新节点 p
		p->data = rand()%100 + 1;  //数据域赋值
		p->next = (*L)->next;
		//将p节点的指针指向头结点后面的节点
		(*L)->next = p;
		//将节点 p 插入到表头
	}
}

建立有头结点的单链表（尾插法）

尾插法和头插法大体类似，不过尾插法需要另外一个指向尾部的结点 r ，在链表中插入元素时，只需要将 r 的指针指向 p 即可，然后将 p 赋值给 r ，这样可以使 r 始终在链表尾部，并且将要插入的元素置于 r 的后方，也就是链表的尾部。插入结束后，将链表尾部的元素的指针指向NULL。

  1. 声明两节点指针 p，r
  2. 初始化随机数种子
  3. 初始化 r 的值和空链表
  4. 在循环里执行如下操作：生成新节点 p，为新节点 p 的数据域随机赋值，将 r 的指针指向 p，将 p 赋值给 r ，执行 n 次。

代码实现：

void CreateListTail(LinkList *L,int n){
	LinkList p,r;
	srand(time(0));
	*L = (LinkList)malloc(sizeof(Node));
	r = *L;
	for(int i = 0 ; i < n ; i++){
		p = (LinkList)malloc(sizeof(Node));
		p->data = rand()%100 + 1;
		r->next = p;
		r = p;
	}
	r->next = NULL;
}

个人的一点感受：

首先就是链表的确很难，在学链表之前，最好先把指针搞懂，明白指针到底是一个什么东西，再来看链表中的指针。这一节的指针太多，很容易把自己搞懵，其实还是需要一点时间来理解。

还有就是最好用笔在纸上写写画画，大致理解有关链表的一些基本操作。然后上机手撕代码，要想真正的把链表吃透，还是需要多敲，多悟，多练（刷题）。

个人虽然可以基本上实现这些基本操作，但有些地方还是似懂非懂，有什么操作和表述上不妥的地方，还望大家指出。

下面给出完整代码的实现（加入测试）：

#include<stdio.h>
#include<stdlib.h>
#include <time.h>
#define MAXSIZE 20

#define ERROR 0
#define OK 1

typedef int Status;
typedef int ElemType;

struct Node{
	ElemType data;
	struct Node * next;
};

typedef struct Node *LinkList;

void InitList(LinkList *L){
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;
} 

bool ListEmpty(LinkList L){
	if(L->next)
		return false;
	else
		return true;
}

void ClearList(LinkList *L){
	LinkList p,q;
	p = (*L)->next;
	while(p){
		q = p->next;
		free(p);
		p = q;
	}
	(*L)->next = NULL;
}

int ListLength(LinkList L){
	int i = 0;
	LinkList p = L->next;
	while(p){
		i++;
		p = p->next;
	}
	return i;
}

Status GetElem(LinkList L,int i,ElemType *e){
	int cnt = 1;
	LinkList p = L->next;
	while(p && cnt < i){
		p = p->next;
		cnt++;
	}
	if(!p)
		return ERROR;
	*e = p->data;
	return OK;
}

int LocateElem(LinkList L,ElemType e){
	int cnt = 0;
	LinkList p = L->next;
	
	while(p){
		cnt++;
		if(p->data == e)
			return cnt;
		p = p->next;
	}  
	
	return 0;
}

Status ListInsert(LinkList *L,int i,ElemType e){
	LinkList p,s;
	p = (*L);
	int cnt = 1;
	while(p && cnt < i){
		cnt++;
		p = p->next;
	}
	if(!p)
		return ERROR;
	s = (LinkList)malloc(sizeof(Node));
	s->data = e;
	s->next = p->next;
	p->next = s;
	return OK;
}

Status ListDelete(LinkList *L,int i,ElemType *e){
	int cnt = 1;
	LinkList q,p;
	p = (*L);
	//此时 p 为头节点，p->next为第一个节点
	while( p->next && cnt < i){
		p = p->next;
		cnt++;
	}
	//第一个节点不为空，并且 cnt 小于要删除的节点位置，开始循环 
	if(!(p->next))
		return ERROR;
	q = p->next;
	p->next = q->next;
	*e = q->data; 
	free(q);
	return OK;
}

Status ListTraverse(LinkList L){
	LinkList p = L->next;
	while(p){
	 	printf("%d ",p->data);
	 	p = p->next;
	} 
	printf("\n");
	return OK;
}

void CreateListHead(LinkList *L,int n){
	LinkList p;
	srand(time(0));
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;
	
	for(int i = 0 ; i < n ; i++){
		p = (LinkList)malloc(sizeof(Node));
		p->data = rand()%100 + 1;
		p->next = (*L)->next;
		(*L)->next = p;
	}
}

void CreateListTail(LinkList *L,int n){
	LinkList p,r;
	srand(time(0));
	*L = (LinkList)malloc(sizeof(Node));
	r = *L;
	for(int i = 0 ; i < n ; i++){
		p = (LinkList)malloc(sizeof(Node));
		p->data = rand()%100 + 1;
		r->next = p;
		r = p;
	}
	r->next = NULL;
}

int main(){
    ElemType e;
    Status r;
    LinkList L;
    InitList(&L);
    printf("初始化L后：ListLength(L) = %d \n",ListLength(L));
    for(int i = 1;i <= 5;i++){
    	r = ListInsert(&L,1,i);
	}
	printf("在表头依次插入1-5后：L.data = ");
	ListTraverse(L);
	
	printf("ListLength(L) = %d \n",ListLength(L));
	r = ListEmpty(L);
	printf("L是否为空：r = %d (1:是 0:否)\n",r);
	
	ClearList(&L);
	printf("清空L后，ListLength(L) = %d \n",ListLength(L));
	r = ListEmpty(L);
	printf("L是否为空：r = %d (1:是 0:否) \n",r);
	
	for(int i = 1; i <= 10 ; i++){
		ListInsert(&L,i,i);
	}
	printf("在L的表尾依次插入1-10后，L.data = ");
	ListTraverse(L);
	
	printf("ListLength(L) = %d\n",ListLength(L));
	
	ListInsert(&L,1,0);
	printf("在表头插入0后：L.data = ");
	ListTraverse(L);
	printf("ListLength(L) = %d\n",ListLength(L));
	
	GetElem(L,5,&e);
	printf("第5个元素的值为%d\n",e);
	
	for(int i = 3 ; i <= 4 ;i++){
		r = LocateElem(L,i);
		if(r)
			printf("第%d位元素的值为%d\n",r,i);
		else
			printf("不存在值为%d的元素\n",i);
	}
	
	int l = ListLength(L);
	for(int i = l + 1; i >= l ; i--){
		r = ListDelete(&L,i,&e);
		if(r == ERROR)
			printf("删除第%d个元素失败\n",i);
		else
			printf("删除第%d个元素值为: %d\n",i,e);
	}
	printf("依次输出L的元素: ");
	ListTraverse(L);
	
	r = 5;
	ListDelete(&L,r,&e);
	printf("删除的第%d个元素的值为：%d\n",r,e);
	
	printf("依次输出L的元素: ");
	ListTraverse(L);
	
	ClearList(&L);
	printf("\n清空L后,ListLength = %d\n",ListLength(L));
	CreateListHead(&L,20);
	printf("整体创建L的元素(头插法)： ");
	ListTraverse(L);
	
	ClearList(&L);
	printf("\n清空L后,ListLength = %d\n",ListLength(L));
	CreateListTail(&L,20);
	printf("整体创建的元素(尾插法)：");
	ListTraverse(L); 
	
    return 0;
}

第二次发博客，希望大家多多关注呀，哈哈！！

小吕编码
关注
  • 636
    点赞
  • 踩
  • 3261
    收藏
    觉得还不错? 一键收藏
  • 51
    评论
专栏目录
链表的C语言实现之动态内存分配
08-03
所谓动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间，而是由系统根据程序的需要即时分配，且分配的大小就是程序要求的大小。
C语言常见问题(七)——动态内存分配之单向链表
易水卷长空的博客
11-19 3818
目录 一、链表 1.什么是链表 2.头指针head 3.链表的节点 二、链表的操作 1.知识准备 2.插入节点 3.链表的遍历 4.检索链表的某个节点 5.删除节点 6.交换链表的两个节点 三、易错点总结 1.头指针head 2.遍历整个链表与检索尾结点的区别 3.哨兵节点 一、链表 1.什么是链表 链表是一种动态数据结构（如图是一个单向链表）。为什么说链表是动态的？是因为链表的节点存储于堆区中，并且在程序运行期间我们可以任意修改链表的长度。 2...
关于链表的总结以及其作用
热门推荐
wislosophia的博客
05-13 2万+
一、链表是什么 1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。 2、结点包括两个部分：一、存储数据元素的数据域（内存空间），二、存储指向下一个结点地址的指针域。 3、相对于线性表顺序结构，操作复杂。 二、链表的作用 1、实现数据元素的存储按一定顺序储存，允许在任意位置插入和删除结点。 2、包括
链表的C语言实现(含动态内存分配)
无界编程
10-22 1万+
链表的C语言实现(含动态内存分配)上 链表的C语言实现之动态内存分配 一、为什么用动态内存分配　　但我们未学习链表的时候，如果要存储数量比较多的同类型或同结构的数据的时候，总是使用一个数组。比如说我们要存储一个班级学生的某科分数，总是定义一个float型（存在0.5分）数组：float score[30];　　但是，在使用数组的时候，总有一个问题困扰着我们：数组应该有多大？　　在很多的情况下，你并
链表
daydreamqun的博客
12-21 707
链表 1.什么是链表 【官方版】链表是一种采用动态存储分配内存的数据结构。（数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合） 【自己】链表即让多个结构体通过指针串在一起成为一条链。即通过当前结构体（包含数据域与结构域）的指针域中存放的指针指向下一个结构体，即当前结构体的指针装着下一个结构体数据的地址。 2.为什么要用链表 一般用来存储数据用的是数组...
如何实现动态分配，malloc,realloc,calloc的使用方法，数组，链表，结构体实现动态分配（含代码实现）
勾栏听曲_0的博客
04-23 3619
教你如何灵活使用malloc,realloc,calloc函数进行动态分配内存空间，并且分析他们的异同\区别；数组怎么动态分配内存空间，结构体怎么动态分配内存空间，链表怎么动态分配内存空间；动态分配内存空间与静态分配的优缺点，什么情况下需要使用动态分配内存空间。
链表创建为什么需要使用内存分配？
主要记录嵌入式学习与开发过程。
09-27 1万+
我们知道，在全局定义的结构体变量，存储全局数据区；在函数内定义的结构体变量，存储在栈区；使用malloc函数申请空间来存放结构体变量，则该结构体变量存储在堆空间中。那假如有1000个在函数内部（栈区）或者函数外部（全局数据区）定义好的结构体，能否直接创建链表？比如下面段代码，提前定义了结构体数组，然后串联成类似“链表”的形式，但假如节点数目大于6，则难以扩展。但是这样徒有链表的形式，不具备链表动态扩展的特点。我们说的链表，其节点数据一般放在堆空间中。...
c语言链表动态分配内存,链表的C语言实现(含动态内存分配)
weixin_31089065的博客
05-21 3146
转自：http://blog.csdn.net/21aspnet/article/details/146968链表的C语言实现(含动态内存分配)上 链表的C语言实现之动态内存分配一、为什么用动态内存分配但我们未学习链表的时候，如果要存储数量比较多的同类型或同结构的数据的时候，总是使用一个数组。比如说我们要存储一个班级学生的某科分数，总是定义一个float型(存在0.5分)数组：float scor...
【C语言】为什么存在动态内存分配
weixin_63449996的博客
04-22 2128
文章目录前言一、动态内存分配定义二、动态内存分配的意义1.可以控制所开辟的内存大小2.可以多次利用这部分空间三，动态内存函数的介绍 前言 提示：我们先来看一个在vs编译器下，同学们常犯的错误 注意：在VS编译器下C语言是不支持变长数组的，我们应该输入一个常量值，如struct Stu s[100]={0};在C99中是支持变长数组的，不同编译器不同，gcc是支持C99的。 一、动态内存分配 定义 我们平常定义的局部变量都是在栈上分配空间的，（1）开辟的空间都是固定的大小，（2）数组在声明的时候，必须指
【数据结构总结笔记（一）--针对概念】
chariyan的博客
08-04 384
用最简介的语言梳理数据结构，多针对概念，以便后期复习
数组和链表的区别和优缺点总结！ 数组和链表.pdf
04-18
数组和链表的区别和优缺点总结！ 数组和链表.pdf
C语言学习笔记，适合刚入门的新手看
09-08
包含图像库、计算机基础、基本数据类型、运算符与表达式、循环与分支、数组、函数、预定义指令、自定义数据类型、指针、库函数、顺序表、链表、栈与队列、文件操作。另外还有一个飞机大战的实战例子。
C语言中关于链表
03-13
C语言中关于链表的总结内容，内附代码例题，详细的有条理的讲解链表内容
C++ 链表模板 语言入门
10-20
C++ 链表模板 语言入门
C语言链表能看得懂的专题培训课件.ppt
11-18
C语言链表能看得懂的专题培训课件.ppt
【数据结构】二叉树（带图详解）
最新发布
Z1tai的博客
04-27 1547
链表和数组都是线性结构，而树是非线性的结构。树是依靠分支关系定义出的一种层次结构。社会亲缘关系和组织结构图都可以用树来形象地表示。
数据结构系列-二叉树之前序遍历
in_seattle的博客
04-26 509
这篇文章，我们主要的内容是对二叉树当中的前历的算法进行讲解，二叉树中的算法所要求实现的是 从根到左子树再到右子树的遍历顺序，可能这样不太好理解，我们拿一张图片进行解释，我们先来分析一下这个的实现逻辑是什么，按照根节点，左子树，右子树的顺序，我们先来判断一下这个应该实现的结果是什么。在这里，我们将空也表现了出来，那下面，我们就讲解一下怎么用代码实现这个过程。假设在这个二叉树当中，我们要实现二叉树遍历当中的前历，我们应该怎么做呢。这些代码我们在前面就详细的进行了展开，在这里我们就不进行详细的讲解。
【数据结构】第二章 线性数据结构.线性表.顺序表
KX_52517的博客
04-26 1350
线性数据结构章节
【数据结构】图（Graph）
2201_75475240的博客
04-24 1306
本文章介绍数据结构中的图的基本知识，包括概念、邻接表、邻接矩阵、深度遍历和广度遍历，且还包含408习题（附有解析）。此外，含有关于邻接表和两种遍历全部具体实现代码。
用c语言写一篇奇偶链表
11-16
以下是用C语言实现奇偶链表的代码和注释： ```c #include #include // 定义链表节点结构体 typedef struct ListNode { int val; struct ListNode *next; } ListNode; // 创建链表函数，返回链表头指针 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值