规范的链表写法之有空头链表

最新推荐文章于 2022-07-10 10:43:03 发布
最新推荐文章于 2022-07-10 10:43:03 发布
阅读量314 收藏 5
点赞数 1
分类专栏： C与C++学习之路 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40162095/article/details/113195960
版权

链表这个东西不是很简单，多次重复学习，看视频敲代码才终于变成自己的知识。

本次讲解的是单向链表，只能通过后面节点找到前面节点，无法通过前面节点找到后面节点。

后续会对双向链表，双向循环链表进行讲解。

文章目录

Ⅰ.无空头的链表

链 表 添 加 { 头 添 加 + 头 删 除 应 用 场 景 − − − 栈 头 添 加 + 尾 删 除 应 用 场 景 − − − 队 列 尾 添 加 + 头 删 除 应 用 场 景 − − − 队 列 链表添加\left\{ \begin{array}{rcl} 头添加+头删除 & &应用场景---栈 \\ 头添加+尾删除& &应用场景---队列\\ 尾添加+头删除& &应用场景---队列 \end{array} \right. 链表添加⎩⎨⎧​头添加+头删除头添加+尾删除尾添加+头删除​​应用场景−−−栈应用场景−−−队列应用场景−−−队列​

1.添加节点，尾添加

#include<stdio.h>
#include<stdlib.h>
//有空头
//节点结构体
struct Node
{
	int a;
	struct Node* pNext;
};
//一个节点记着头（用来遍历链表），一个记着尾,头尾指针都为空，说明链表里没有节点
struct Node* g_pHead = NULL;
struct Node* g_pEnd = NULL;
//创建链表。在链表中增加一个数据
//尾添加
void AddListToTail(int a)
{
	//创建一个节点
	//在vs里malloc会自动进行数据类型转换，但是在别的编译器里，不写强制类型转换，该malloc会报错。
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	pTemp->a = a;
	pTemp->pNext = NULL;//这里很重要，保证最后一个节点指向空，遍历时作为遍历退出条件
	//将新节点链接到链表上----分两种情况：
	//1.链表里还没有节点，链表添加第一个节点时，头节点和尾节点指向同一位置
	if (NULL == g_pHead || NULL == g_pEnd)//其实这里只需要一个判断就够了，不需要 || 因为其中有一个为空就说明该链表为空 
	{
		g_pHead= pTemp;
		g_pEnd = pTemp;
	}
	//2.链表从第二个节点开始，头节点就不需要再变化了，只需要尾节点添加就行了
	else
	{
		//由于指针的性质，两个指针指向同一位置时，通过其中一个指针就可以改变所指位置的值，自然指向该位置的另一个指针所指的值就变了。
		//这里就是通过g_pEnd->pNext = pTemp;语句改变g_pEnd所指节点成员pNext的值，而g_pEnd是单独的一个节点，它便按照规则也就是下一个节点，指向尾节点。
		g_pEnd->pNext = pTemp;//前一个节点的next连接到新的节点
		g_pEnd = pTemp;
	}
	//由于g_pEnd = pTemp;在两个分支里都有，所以可以写成如下形式
	/*
	if (NULL == g_pHead || NULL == g_pEnd)//其实这里只需要一个判断就够了，不需要 || 因为其中有一个为空就说明该链表为空
	{
		g_pEnd = pTemp;
	}
	else
	{
		g_pEnd->pNext = pTemp;
	}
	g_pEnd = pTemp;
	*/
}

(1)划重点

根据指针的性质，两个指针指向同一位置时，通过其中一个指针就可以改变所指位置的值，自然指向该位置的另一个指针所指的值就变了。
链表尾添加就是通过这一性质完成的。

g_pEnd->pNext = pTemp;
g_pEnd = pTemp;

(2)测试

int main()
{
	AddListToTail(1);
	AddListToTail(2);
	AddListToTail(3);
	AddListToTail(4);
	g_pHead;
	system("pause");
	return 0;
}

打断点查看链表添加情况，可以看到数据逐一添加到头节点后面。最先添加的数据在前面，最后添加的数据在后面，和队列的性质一样。
在这里插入图片描述

(3)使用链表添加数组数据

int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
for (int i = 0; i < sizeof(a)/sizeof(a[0]); i++)
{
	AddListToTail(a[i]);
}

2.添加数据，头添加

//创建链表。在链表中增加一个数据
//头添加
void AddListToHead(int a)
{
	//创建一个节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	//节点数据赋值
	pTemp->a = a;
	pTemp->pNext = NULL;//这里很重要，保证第一个点指向空，遍历时作为遍历退出条件
	//将新健节点链接到链表上----分两种情况：
	//1.链表里还没有节点，链表添加第一个节点时，头节点和尾节点指向同一位置
	if (NULL == g_pHead || NULL == g_pEnd)
	{
		g_pEnd = pTemp;
		g_pHead = pTemp;
	}
	//2.链表从第二个节点开始，尾节点就不需要再变化了，只需要新节点pTemp指向头节点，头节点再更新指向新节点
	else
	{
		//注意，下面这样写是错误的，这样写是假的头添加，相当于只是给头尾指针换了个名字
		//尾添加是尾节点的next指向新节点，头添加是新节点的next指向头
		//这是头添加和尾添加最大的区别
		/*
		g_pHead->pNext = pTemp;
		g_pHead = pTemp;
		*/
		//正确写法
		//新节点的next指向头
		pTemp->pNext = g_pHead;
		g_pHead = pTemp;
	}
	//由于g_pHead = pTemp;在两个分支里都有，所以可以写成如下形式
	/*
	if (NULL == g_pHead || NULL == g_pEnd)
	{
		g_pEnd = pTemp;
	}
	else
	{
		pTemp->pNext = g_pHead;
	}
	g_pHead = pTemp;
	*/
}

(1)划重点

注意，下面这样写是错误的，这样写是假的头添加，相当于只是给头尾指针换了个名字。当添加第二个及其后续节点时，尾添加是尾节点的next指向新节点，头添加是新节点的next指向头，这是头添加和尾添加最大的区别。
错误写法

g_pHead->pNext = pTemp;
g_pHead = pTemp;

正确写法

pTemp->pNext = g_pHead;
g_pHead = pTemp;

(2)测试

int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
	for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
	{
		AddListToHead(a[i]);
	}

打断点查看链表添加情况，可以看到数据逐一添加到链表中，最先添加的数据在底部，而最后添加的数据在顶部，和栈的性质一样。
在这里插入图片描述

3.遍历链表

遍历查询数据

void ScanList()
{
	//操作链表时，头指针不能动，头指针动了，链表的头就找不到了。	
	//建立一个新指针用来遍历
	struct Node* pTemp = g_pHead;
	while (pTemp != NULL)//非空链表不遍历
	{
		printf("%d\n",pTemp->a);
		pTemp = pTemp->pNext;
	}
}

注意这里的判断条件也可以写成while (pTemp)，不会出错，最好写成while (pTemp != NULL)，一般只有bool型变量这样写—while(b) 以及while(! b)

(1)测试

在这里插入图片描述

(2)划重点

节点数据赋值前的预操作

pTemp->a = a;
pTemp->pNext = NULL;//这里赋值为NULL很重要

  • 对于尾添加，保证最后一个节点指向空，遍历时作为遍历退出条件

  • 对于头添加，保证第一个点指向空，遍历时作为遍历退出条件

如果没有进行上述操作，会出现如下错误，出现了野指针，这是不被允许的。
在这里插入图片描述

4.查询指定节点

(1)代码

struct Node* SelectNode(int a)
{
	struct Node* pTemp = g_pHead;
	while (pTemp != NULL)
	{
		if (a == pTemp->a)
		{
			return  pTemp;
		}
		pTemp = pTemp->pNext;
	}
	return NULL;
}

(2)测试

该节点存在
在这里插入图片描述
该节点不存在
在这里插入图片描述

5.链表释放

(1)基础知识

本例子使用了

struct Node* pTemp = g_pHead;

与之前的

struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));

相比较，提出了本问题：什么时候定义指针需要用malloc分配内存，什么时候不需要。弄清楚这一点对彻底理解清楚程序很有必要。首先需要了解一下几点：

  • C、C++中，内存模型分为栈和堆，这两种模型内存的方式是不同的。
  • 在栈中存放的变量是由系统自动管理的，在函数结束后系统会自动释放，不需要人为的任何操作。
  • 在堆中存放的是用户自己管理的内存，手动分配的，malloc建立，系统不会在函数体执行结束后自动释放，需要用户手动通过free函数释放。
  • 当需要对分配的空间进行自己的管理和释放时，需要实用malloc，或者分配的空间再函数结束后还需要存在。

下面列举一个学习链表初期容易犯的错误：
在释放某一节点前，需要再定义一个节点（不需要malloc）记住要删除的节点，然后pTemp指向pTemp的下一节点，否则会出错，出现访问错误的问题。
在这里插入图片描述

(2)链表释放代码

//链表清空
//数组释放，只需要释放首地址，该数组就全部释放掉了
//链表释放需要循环遍历释放每一个节点
void FreeList()
{
	//记录头
	struct Node* pTemp = g_pHead;
	while (pTemp != NULL)//非空链表不遍历
	{
		struct Node* pt = pTemp;//定义一个节点记住pTemp，待删除
		pTemp = pTemp->pNext;//pTemp指向下一个节点
		free(pt);
	}
	//头尾清空，方便下一次创建
	g_pHead = NULL;
	g_pEnd = NULL;
}

6.插入节点

(1)代码

void AddListRand(int index, int a)
{
	//链表为空
	if (NULL == g_pHead)
	{
		printf("链表没有指定节点");
		return;
	}
	//找位置
	struct Node* pt = SelectNode(index);
	if (NULL == pt)
	{
		printf("没有指定节点\n");
		return;
	}
	//有此节点
	//给a创建节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	//节点成员赋值
	pTemp->a = a;
	pTemp->pNext = NULL;
	//链接到链表上
	if (pt == g_pEnd)
	{
		g_pEnd->pNext = pTemp;
		g_pEnd = pTemp;
	}
	else
	{
		//先连
		pTemp->pNext = pt->pNext;
		//后断
		pt->pNext = pTemp;
	}
}

(2)测试

在这里插入图片描述

7.删除节点

1.头删除

代码

//头删除
void DeleteListHead()
{
	//链表检测
	if (NULL == g_pHead)
	{
		printf("链表为NULL,无需释放\n");
		return;
	}
	//记住旧的头
	struct Node* pt = g_pHead;
	//头的下一个节点变成新的头
	g_pHead = g_pHead->pNext;
	//释放旧的头
	free(pt);
}

测试
在这里插入图片描述

2.尾删除

划重点
要先找到尾节点的前一个节点，否则直接删除了尾节点，g_pEnd就无法再容易的找到旧的尾节点的前一个节点。
代码

void DeleteListTail()
{
	//链表检测
	if (NULL == g_pHead)
	{
		printf("链表为NULL,无需释放\n");
		return;
	}
	//链表不为空
	//链表有几个节点，一个节点和多个节点的情况不一样
	//链表只有一个节点
	if (g_pHead == g_pEnd)
	{
		free(g_pEnd);
		//头尾一定要赋空值
		g_pHead = NULL;
		g_pEnd = NULL;
	}
	else
	{
		//找到尾巴前一个节点
		struct Node* pTemp = g_pHead;
		while (pTemp->pNext != g_pEnd)
		{
			pTemp = pTemp->pNext;
		}
		//找到了，删除尾巴
		//释放尾节点
		free(g_pEnd);//释放g_pEnd所指区域的空间
		//尾巴前移
		g_pEnd = pTemp;//g_pEnd作为一个单独的变量还是可以继续使用的
		//尾巴的next指针赋空值NULL
		g_pEnd->pNext = NULL;
	}
}

测试
在这里插入图片描述

3.指定节点删除

注意先判断链表是否为空，还要判断该数据对应的节点是否存在。考虑要周全，要分三种情况，(1)链表有一个节点，(2)两个节点，(3)两个以上节点。两个节点时要判断要删除的节点是头节点还是尾节点；三个以上节点删除时还多一种情况，判断要删除的节点是中间节点的情况。
代码

//指定节点删除
void DeleteListRand(int a)
{
	//链表检测
	if (NULL == g_pHead)
	{
		printf("链表为NULL,无需释放\n");
		return;
	}
	//链表有该元素
	struct Node* pTemp = SelectNode(a);
	if (NULL == pTemp)
	{
		printf("查无此节点\n");
		return;
	}
	//找到了该节点，分为三种情况
	//1.链表中只有一个节点
	if (g_pHead == g_pEnd)
	{
		DeleteListHead();
	}
	//2.链表中有两个节点
	else if (g_pHead->pNext == g_pEnd)
	{
		//分为两种情况
		//1.要删除的是头节点
		if (g_pHead == pTemp)
		{
			DeleteListHead();
		}
		//2.要删除的是尾节点
		else
		{
			DeleteListTail();
		}
	}
	//3.链表中有两个以上的节点
	else
	{
		//分为三种情况
		//1.要删除的是头节点
		if (g_pHead == pTemp)
		{
			DeleteListHead();
		}
		//2.要删除的是尾节点
		else if(g_pEnd == pTemp)
		{
			DeleteListTail();
		}
		//删除除了头尾节点以外的节点
		else
		{
			//找到要删除节点Ptemp的前一个节点
			struct Node* pt = g_pHead;
			while (pt->pNext != pTemp)
			{
				pt = pt->pNext;
			}
			//找到了
			pt->pNext = pTemp->pNext;
			free(pTemp);
		}
	}
}

测试
在这里插入图片描述

Ⅱ.有空头的链表

1.尾添加

(1)代码

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

//节点结构体
struct Node
{
	int a;
	struct Node* pNext;
};
//头尾指针定义
struct Node* g_pHead = NULL;
struct Node* g_pEnd = NULL;
//尾添加
void AddListTail(int a)
{
	//创建一个节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	//节点成员赋值
	pTemp->a = a;
	pTemp->pNext = NULL;
	//链接
	//与无空头的链表相比，不需要再单独考虑头节点了
	g_pEnd->pNext = pTemp;
	g_pEnd = pTemp;
}

(2)测试

int main(void)
{
	//链表空头
	//有空头初始化，也简化了链表操作时对头节点的单独考虑，也就不需要再单独考虑头节点了
	g_pHead = (struct Node*)malloc(sizeof(struct Node));
	g_pHead->pNext = NULL;//空头成员不用管
	g_pEnd = g_pHead;
	
	AddListTail(1);
	AddListTail(2);
	AddListTail(3);
	AddListTail(4);
	return 0;
}

划重点
有空头初始化，也简化了链表操作时对头节点的单独考虑，也就不需要再单独考虑头节点了

g_pHead = (struct Node*)malloc(sizeof(struct Node));
g_pHead->pNext = NULL;//空头成员不用管
g_pEnd = g_pHead;

测试结果
在这里插入图片描述

2.头添加

(1)将空头链表初始化和创建节点进行封装

这样做是为了简化代码，看起来更加简洁

//空头链表初始化
void InitListHead()
{
	//链表空头
	//有空头初始化，也简化了链表操作时对头节点的单独考虑，也就不需要再单独考虑头节点了
	g_pHead = (struct Node*)malloc(sizeof(struct Node));
	g_pHead->pNext = NULL;//空头成员不用管
	g_pEnd = g_pHead;
}

//创建节点
struct Node* CreatNode(int a)
{
	//创建一个节点
	struct Node* pTemp = (struct Node*)malloc(sizeof(struct Node));
	if (NULL == pTemp)
	{
		printf("内存不足\n");
		return NULL;
	}
	//节点成员赋值
	pTemp->a = a;
	pTemp->pNext = NULL;
	return pTemp;
}

(2)头添加代码

//头添加
void AddListHead(int a)
{
	struct Node* pTemp = CreatNode(a);
	if (NULL == pTemp)
	{
		return;
	}
	//链接
	pTemp->pNext = g_pHead->pNext;
	g_pHead->pNext = pTemp;
}

(3)测试

代码

int main(void)
{
	//空头链表初始化
	InitListHead();
	AddListHead(0);
	AddListHead(1);
	AddListHead(2);
	AddListHead(3);
	g_pHead;
	return 0;
}

测试结果
在这里插入图片描述

本内容来源于b站C3程序猿的视频讲解，这是我见过最好的视频讲解

龙叙
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
无空头链表的完整代码
weixin_46539107的博客
11-13 84
#include <stdio.h> #include <stdlib.h> struct node{ int a; struct node *pnext; }; //头尾指针 struct node *phead=NULL; struct node *pend=NULL; //遍历链表 void scanlist(); //尾添加 void wtj(int a); //头添加 void ttj(int a); //指定位置添加数据 void tianjiashuj
规范链表操作
RealPresence and Media Collaboration 专栏
06-25 423
//////////////////////////////////////////////////////////////// lnklst.c// definition of queue functions#include stdlib.h>#include "lnklst.h"struct basic_nod_t {    struct basic_nod_t *next;};static
【数据结构】——较规范的链表操作方法
weixin_34403693的博客
02-23 91
　　net小伙曾在文章【数据结构】双向链表的创建和读取和【数据结构】链式线性表的几种常用用法中写过关于线性表的操作方法，重新阅读发现代码很是稚嫩，现重新整理。 　　一般情况下我们会使用一个结构体head来作为双向链表的头部，head有两个指针域，一个指向链表的开始，一个指向链表的末尾。双向链表的指针域也有两个，一个指向前一个节点，一个指向后一个节点。两个结构体定义如下： 1 #defin...
有空头链表
taw19960426的博客
05-23 468
#include <stdio.h> #include <stdlib.h> //节点结构体 struct Node { int a; struct Node *pNext; } ; //头尾指针定义 struct Node *g_pHead=NULL; struct Node *g_pEnd=NULL; //空头链表初始化 void LianBiaoCh...
有空头单链表和无空头单链表
qq_44061866的博客
07-26 178
https://blog.csdn.net/songsong2017/article/details/88024883 初学者参照上面博客的图 指针 <- 结点地址 有空头链表 头插法创建链表 //编译器vs2019 #include<stdlib.h> #include<stdio.h> #include<malloc.h> typedef struct Node { int data; struct Node* next; }Node; //头插法
双指针法判断链表有环-Java 版
最新发布
04-26
附件是使用双指针发判断链表有环的代码实现，在Java中，判断单链表是否有环的经典方法是使用Floyd的“龟兔赛跑”算法，也称为快慢指针法。这种方法利用两个指针，一个每次走一步（称为慢指针），另一个每次走两步...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
c语言编程题之链表操作回文链表.zip
03-30
在C语言编程中，链表是一种非常重要的数据结构，它不同于数组，不连续存储数据，而是通过节点间的指针连接形成。本题目的焦点在于如何处理链表，特别是检查一个链表是否为回文链表。回文链表是指链表从前到后和从后...
c语言编程题之链表操作设计链表.zip
03-30
链表可以是单向的，其中每个节点仅有一个指向前一个或后一个节点的指针，也可以是双向的，每个节点有两个指针，分别指向前后节点。 2. 创建链表： 创建链表首先需要定义节点结构体，例如： ```c typedef struct ...
C语言之单向链表详解及实例代码
12-31
其中每个结点都有指针成员变量指列表中的下一个结点；列表是由结点构成，由head指针指向第一个成为表头的结点而终止于最后一个指向nuLL的指针； 2，例子要求： 根据示例代码中的例子，完成单向链表(single linked ...
LeetCode Add Two Numbers 空头节点
餃子屋
08-14 536
Add Two Numbers，用链表求两数之和。两个链表中对应位置的数，以及进位carry相加，用得到的结果更新carry，更新result链表。
单链表（数据结构）
小的博客
08-02 8543
链表链表概念空表的表示单链表的实现单链表的建立1.头插法2.尾插法 链表概念 线性表的链式存储结构：线性表中数据元素（结点）在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理位置上不一定相邻。 1. 相关术语 结点：数据元素的存储映像。由数据域和指针域两部分组成。 数据域：存放数据 指针域：存放指向下个结点的地址 链表：n个结点由指针链组成一个链表 2.头指针、头结点、首元结点 头指针:是指向链表中第一个结点的指针 头结点：是在链表的首元结点之前附设的一个结点 首元节点：是指链表中存储第一个数
Leap Day4——数据结构与算法 链表表示和实现
胖虎虎
01-10 807
目录 1、链表的概念 1.1 链表的定义 1.2 头指针、头结点和首元结点 1.3 空表的表示 1.4 头结点的好处 1.5 头结点的数据域 1.6 链表（链式存储结构）的特点 2、单链表的定义 3、单链表的基本操作 3.1 初始化 3.2 判断空表 3.3 销毁 3.4 清空 3.5 求单链表的表长 3.6 取第i个元素值 3.7 查找 3.7.1 按值查找 3.7.2 按位查找 3.8 插入 3.9 删除 4、建立单链表 4.1 头插法——每次插在头结点的
数据结构：单链表
咩咩的博客
06-19 1148
单链表：由头指针唯一确定，因此单链表可以用头指针的名字来命名。 如何表示空表？ 无头节点时，头指针为空时表示空表 有头节点时，当头结点的指针域为空时为空表 typedef struct LNode//声明结点类型 和 指向结点的指针类型 { ElemType data;//结点的数据域 struct LNode* next;//结点的指针域 }LNode,*LinkList;//LinkList为指向结构体LNode的指针类型 存储学生学号、姓名、成绩的单链表结点类型定义如下： typ
java list 最后一个_怎样获取list集合中的最后一个对象中的值
weixin_31190007的博客
02-12 8964
展开全部指令：list.get(list.size()-1);C语言中List的含义：链表是一种物理存储单元上非连续、非顺32313133353236313431303231363533e78988e69d8331333365646263序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成，结点可以在运行时动态生成。每个结点包括两个部分...
数据结构——单链表操作
_nplus
01-15 2482
数据结构上机测试2-1:单链表操作A Time Limit: 1000MS Memory limit: 4096K 题目描述 输入n个整数，先按照数据输入的顺序建立一个带头结点的单链表，再输入一个数据m,将单链表中的值为m的结点全部删除。分别输出建立的初始单链表和完成删除后的单链表。 输入 第一行输入数据个数n； 第二行依次输入n个整数； 第三行输入欲删除数据
数组实现的队列为什么需要一个空节点
qq_42902163的博客
09-26 1771
对队列指针的三种设计： （1）font指向第一个节点，rear指向最后的节点 （2）font指向第一个节点的前一个空节点，rear指向最后的节点 （3）font指向第一个节点，rear指向最后节点的下一个节点 综合来看第二种最好：（个人理解） 若使用第一种：在初始化时font=rear=-1.在加入第一个元素时，两个指针都要移动1。判断空的条件是font=rear=-1或者font-rear=-1...
单链表——单链表的定义及基本操作（初始化、头插法尾插法建表、查找、插入、删除、判空等）
薛定谔的猫的博客
04-17 9万+
文章目录单链表的定义单链表上的操作初始化建立单链表头插法建立单链表尾插法建立单链表遍历单链表求单链表的长度查找操作按值查找按位查找插入操作删除操作完整代码及实例 单链表的定义   由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它不要求在逻辑上相邻的两个元素在物理位置上也相邻。   单链表的特点： 单链表不要求逻辑上相邻的两个元素在物理位置上也相邻，因此不需要连续的存储
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 17万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

龙叙

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

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

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

打赏作者

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

抵扣说明：

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

余额充值