数据结构之：链表详解

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

链表是 数据结构中很重要的基础 部分，下面 我通过简单的故事来将链表的内容串起来解释一下，同时也是总结一下自己的学习内容：

故事：

某一天，乐乐，丰丰，呆子，星星，领领，小韦6位小朋友带领着8个小朋友一起去山上玩耍。当玩耍过后，天下起了大雨 ！！于是 14位小朋友赶紧返回，不幸的是山口处山洪暴发。如果想要 过去，14位 小朋友需要连在一起，单个过河的小朋友会被山洪冲走(因为经过试验证明了这一点，而且小韦在试验过程中被洪水冲走了) 。

我们将每位小朋友看做是一个节点。

typedef struct Lnode
{
	int data;    //小朋友数据
	struct Lnode *next;   //指向下一个小朋友的指针
};


建立单链表：

那么要从洪水中过去的话，14位小朋友需要建立一个长队。可以想到，建立长队的方法有两种：

首先我们需要空出来一块场地用来建立我们的长队(所说的建立 一个空链表)

code：

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


第一种：乐乐站在第一个，星星站在乐乐 的前面，呆子站在星星的前面……依次排列，这样乐乐会最终站在队尾（这就是头插法建立单链表）。

               1. 2 .3.……丰丰，呆子，星星，乐乐。

code:

void CreateListH(LinkList *&L, int a[], int n)   //头插法建立单链表
{
	LinkList *s;                            //s是要插入的小朋友
	int i;
	L = (LinkList *)malloc(sizeof(LinkList)); //申请空间，
	L->next = NULL;                          //刚开始的时候为空，因为还没有排队。
	for (i = 0; i < n; i++)                 //我们将后来的小朋友插入前面，并让这个的小朋友的手拉着站在他后面的小朋友的衣服
	{
		s = (LinkList *)malloc(sizeof(LinkList));
		s->data = a[i];
		s->next = L->next; 
		L->next = s;
	}
}



第二种：乐乐站在第一个，星星 站在乐乐的后面，呆子站在星星的后面，丰丰站在呆子的后面，……其他人依次后排(这就是尾插法建立单链表)。

               乐乐，星星，呆子，丰丰……。

Code：

void  CreateListR(LinkList *&L, int a[], int n)
{
	int i;
	LinkList *s, *r;
	L = (LinkList *)malloc(sizeof(LinkList));  //申请空间
	r = L;
	for (i = 0; i < n; i++)      // s是要插入的小朋友，r只是一个临时标记，为了知道现在谁在最后的位置
	{
		s = (LinkList *)malloc(sizeof(LinkList));
		s->data = a[i];
		r->next = s;            //将 s小朋友插入r的后面，
		r = s;      //插入后，那么s在最后的位置，让其成为标记。因为我们需要知道谁在最后面，方面下次的插入操作
	}
	r->next = L->next;             //队伍建立完成后，最后  队尾节点为 NULL；
}



那么现在队伍建立完成了，可以过河了，小朋友们都很高兴（其实 一点都不高兴）。

这个时候小韦竟然回来了，小朋友们都很高兴他还 或活着，选举他当了队长 。由于小韦刚回来 ，对队伍的情况 不是 很了解，他想要知道队伍有多少人，于是他从队伍的头到尾进行了查数：

（单链表中数据 节点 的个数）

code：

int ListLength(LinkList *L)
{
	int ans = 0;
	LinkList *p = L;     //小韦学长找到了队伍头部 
	while (p->next != NULL)   //直到尾部，看到一个小朋友 就ans++；
	{
		ans++;
		p = p->next;
	}
	return ans;
}

但是 悲剧的是，小韦由于智商有限，只能数到10，就不会数了。于是他想了一个方法，让队伍中的小朋友从头到尾 说出自己的名字、信息：

（输出节点存储的信息）：

code：

void CoutList(LinkList *L)
{
	LinkList *p = L->next;  //从 有效节点开始
	while (p != NULL)
	{
		printf("%d", p->data);  //小朋友喊出自己的信息
		p = p->next;          //换下一个小朋友
	}
}



由于小韦只能数到10，造成队伍中的星星的嘲笑，并给他 起了个外号：小白。站在队伍头部的小韦很是气愤，气愤中的小韦突然就知道怎么数10以后的数字了。于是他查了一下嘲笑他的小朋友的位置，给他起外号报复：

修改某个节点的数据信息 ：

code：

bool ChangeInfo(LinkList *&L, int i, int &e)    //小韦查到了星星的位置，想好了外号
{
	int j = 0;
	LinkList *p = L;
	while (j < i && p != NULL)                  //如果是不在数据范围内，说明小韦的数学真的很菜
	{
		j++;
		p = p->next;
	}
	if (p == NULL)
		return false;
	else
	{
		p->data = e;                         //如果找到了i位置上的星星，小韦就把他想好的外号赋予星星
		return true;
	}
}



由于小韦的行为，使得某个位置上的乐乐表现的很气愤。于是小韦查了乐乐的位置，并行使了队长权利将其踢出了队伍（因为 小韦知道乐乐未来会是一位IT大神，要让乐乐挂掉先）。

删除某个节点：

bool ListDelete(LinkList *&L, int i)    //找到乐乐的位置
{
	int j = 0;
	LinkList *p = L, *q;
	while (j < i - 1 && p != NULL)   
	{
		j++;
		p = p->next;
	}
	if (p == NULL)                  //如果找错了，不存在i节点，说明小韦的 数学是体育老师教的，
		return false;
	else
	{
		q = p->next;             //如果找到了乐乐，把乐乐一觉踹出队伍，再让乐乐前面的小朋友的手拉着乐乐后面 的小朋友的衣服
		if (q == NULL)
		{
			return false;
		}
		p->next = q->next;        
		free(q);
		return true;
	}
}



杂七杂八的事情终于弄完了，于是 小韦也归队。（因为他 不想再单独被冲走了）

插入数据元素：

code：

bool ListInsert(LinkList *&L, int i, int e)  //小韦在某个位置上插入队伍
{
	int j = 0;
	LinkList *p = L, *s;
	while (j < i - 1 && p != NULL)
	{
		j++;
		p = p->next;
	}
	if (p == NULL)
		return false;
	else
	{
		s = (LinkList *)malloc(sizeof(LinkList));
		s->data = e;
		s->next = p->next;
		p->next = s;
		return true;
	}
}

那么 现在开始过河了，由于河水  突然猛涨，小韦学长竟然又被冲走了。小伙伴们需要抓的更紧点，于是它们退回来重新 建队。并将抓衣服的方式 更改了一下：让前一个小朋友的手抓住后一个小朋友的衣服，后一个小朋友的手抓住他前面的小朋友的衣服。即（双链表）

相应的此时建双链表的方法也有两种，与建立单链表过程相似，只需要加一个前驱结点即可：

code：

typedef struct Lnode
{
	int data;
	struct Lnode *prior;  //前驱节点
	struct Lnode *next;   //后继节点
}LinkList;


第一种建立方式头插法（与单链表头插法相似）：

code：

void CreateList_F(LinkList *&L, int a[], int n)
{
	LinkList *s;
	int i;
	L = (LinkList*)malloc(sizeof(LinkList));
	L->prior = L->next = NULL;
	for (i = 0; i < n; i++)
	{
		s = (LinkList *)malloc(sizeof(LinkList));
		s->data = a[i];
		s->next = L->next;
		if (L->next != NULL)
		{
			L->next->prior = s;
		}
		L->next = s;
		s->prior = L;
	}
}



尾插法建立 双链表：

code:

void CreatList_R(LinkList *&L, int a[], int n)
{
	int i;
	LinkList *s, *r;
	r = L;
	for (i = 0; i < n; i++)
	{
		s = (LinkList*)malloc(sizeof(LinkList));
		s->data = a[i];
		r->next = s;
		s->prior = r;
	}
	r->next = L->next;
}


经过好多坎坷，终于到达的河的对岸，于是小伙伴们 手拉手围成一个圈，兴高采烈的哭了起来。

循环链表：

循环链表 只是将链表 的尾部节点的 next指向了链表 的开头L；

下面我总结下代码：


单链表：

typedef struct Lnode    //数据节点
{
	int data;
	struct Lnode *next;
}LinkList;


void InitList(LinkList *&L)   //创建空的单链表
{
	L = (LinkList *)malloc(sizeof(LinkList));
	L->next = NULL;
}


void CreateListH(LinkList *&L, int a[], int n)    //头插法建立单链表
{
	LinkList *s;                                    
	int i;
	L = (LinkList *)malloc(sizeof(LinkList));   L是 链表的头
	L->next = NULL;                             
	for (i = 0; i < n; i++)                   //将数据插入链表头（L）的后面
	{s = (LinkList *)malloc(sizeof(LinkList));
		s->data = a[i];
		s->next = L->next;               //即：s指向 L的 指向，L指向s；
		L->next = s;
	}
}

  
void  CreateListR(LinkList *&L, int a[], int n)  //尾插法建立单链表
{
	int i;
	LinkList *s, *r;
	L = (LinkList *)malloc(sizeof(LinkList));  //申请空间。开始时L虽然是表头 ，同时也是尾
	r = L;
	for (i = 0; i < n; i++)      //              //将下一个 数据插入队尾的后面，再让该数据成为新的队尾
	{s = (LinkList *)malloc(sizeof(LinkList));
		s->data = a[i];
		r->next = s;            //r就是队尾部，将 s插入r的后面，
		r = s;                 //插入后，那么s在最后的位置，让其成为标记。现在s就是新的队尾
	}
	r->next = L->next;             //队伍建立完成后，最后  队尾节点为 NULL；
}
</pre><pre code_snippet_id="1630697" snippet_file_name="blog_20160331_15_6131477" name="code" class="cpp">
int ListLength(LinkList *L)                  //返回单链表的长度
{
	int ans = 0;
	LinkList *p = L;                         //(要注意是LinkList * p = L)
	while (p->next != NULL)                 //如果 下一个节点不为空，肯定是有数据存储的，于是ans++；
	{
		ans++;
		p = p->next;
	}
	return ans;
}


void CoutList(LinkList *L)                    //输出每个节点的信息
{
	LinkList *p = L->next;                 //从头开始（要注意是LinkList *p = L->next）
	while (p != NULL)                       //如果当前节点不为空，则 输出信息
	{
		printf("%d", p->data);
		p = p->next;
	}
}


bool GetElem(LinkList *&L, int i, int &e)             //修改某个位置上的数据信息
{
	int j = 0;
	LinkList *p = L;
	while (j < i && p != NULL)                          //如果没有遍历到i-1并且链表没有结束
	{
		j++;                                        //接着找
		p = p->next;
	}
	if (p == NULL)                                         //如果结束时是因为链表结束了，则说明 i超出了范围
		return false;
	else                                                     //否则，修改信息
	{
		p->data = e;
		return true;
	}
}

bool ListDelete(LinkList *&L, int i)                          //删除某个节点
{
	int j = 0;
	LinkList *p = L, *q;
	while (j < i - 1 && p != NULL)
	{
		j++;
		p = p->next;
	}
	if (p == NULL)
		return false;
	else                                                  //如果找到了该节点，
	{
		q = p->next;                                  //那么让当前节点的后记节点指向它后面 的后面，就相当于把 这个节点隔出来了
		if (q == NULL)
		{
			return false;
		}
		p->next = q->next;
		free(q);
		return true;
	}
}

bool ListInsert(LinkList *&L, int i, int e)               //  插入节点
{
	int j = 0;
	LinkList *p = L, *s;
	while (j < i - 1 && p != NULL)
	{
		j++;
		p = p->next;
	}
	if (p == NULL)
		return false;
	else                                              //如果  找到位置，先让要插入的s节点指向当前节点的后继，并让当前节点的后继指向s。
	{
		s = (LinkList *)malloc(sizeof(LinkList));
		s->data = e;
		s->next = p->next;
		p->next = s;
		return true;
	}
}




双链表： 


typedef struct Lnode   //双链表节点
{
	int data;
	struct Lnode *prior;
	struct Lnode *next;
}LinkList;




void CreateList_F(LinkList *&L, int a[], int n)   //头插法建立双链表
{
	LinkList *s;
	int i;
	L = (LinkList*)malloc(sizeof(LinkList));
	L->prior = L->next = NULL;                  //首先头部节点的next 和prior为空
	for (i = 0; i < n; i++)
	{
		s = (LinkList *)malloc(sizeof(LinkList)); 
		s->data = a[i];
		s->next = L->next;
		if (L->next != NULL)                     //如果头部节点的next不为空，那么L的下个节点的prior必须要指向s
		{
			L->next->prior = s;
		}
		L->next = s;                              //L的 next指向 s，s的 前驱节点指向L。
		s->prior = L;
	}
}




void CreatList_R(LinkList *&L, int a[], int n)  尾插法建立双链表
{
	int i;
	LinkList *s, *r;
	r = L;
	for (i = 0; i < n; i++)
	{
		s = (LinkList*)malloc(sizeof(LinkList));  //只需要 让新加入的节点  的前驱节点指向当时队尾即可，不用 考虑头部L，因为是 尾插法。
		s->data = a[i];
		r->next = s;
		s->prior = r;
	}
	r->next = L->next;
}


循环链表  的就不写了，因为只需要 让尾节点和头结点关联上就行了，不过要注意双链表循环和单链表循环是有一定区别的。但是本质不变。

希望  这篇文章 可以 帮助你更好的理解或者复习链表操作 。

如有错，请留言。

Mr_Lsz
关注
专栏目录
C#数据结构之双向链表(DbLinkList)实例详解
09-03
主要介绍了C#数据结构之双向链表(DbLinkList),结合实例形式较为详细的讲解了双向链表的概念及C#实现双向链表的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的链接。 根据结构的不同，链表可以分为单向链表、单向循环链表、双向链表、双向循环链表等。其中，单向链表和单向循环链表的结构如下图所示： 二、ADT 这里只考虑单向循环链表ADT，其他类型的链表ADT大同小异。单向循环链表ADT（抽象数据类型）一般提供以下接口： ① SinCycLinkedlist() 创建单向循环链表 ② add(item) 向链表中插入数据项 ③ remove
数据结构——链表 原理及C语言代码实现（可直接运行版）
最新发布
m0_63596031的博客
02-16 402
存储都在数据段上，而在函数内部临时开辟的则存储在栈区（记忆技巧：栈区后来先出，生命周期短，适合存储临时使用的变量，在函数执行结束时会自动被释放），堆区存放的则是在函数运行过程中开辟出来的空间，需要程序员进行手动分区以及释放，也可能程序结束时由OS回收，所以也可能会发生内存泄漏问题。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
通讯录（链表实现）
ajl2003的博客
07-03 1355
通讯录链表实现
全面理解链表数据结构：各种节点操作、做题技巧，易错点分析与题目清单（C++代码示例，不断更新）
weixin_49503250的博客
05-27 1660
我们都知道，单向链表这种数据结构都是由一个个节点组成的，那单向链表节点这种结构体都由什么组成呢？当然是由一个节点的值，与节点的一个next指针组成，以及构建节点的构造函数组成。其中节点的next指针，指向了该链表的下一个节点的元素位置。所以，当我们创建单向链表节点的这个结构体的时候，需要指定以下元素节点的值节点的next指针节点的构造函数（用于初始化一个新的节点，不然如何创建一个新的节点（链表）呢？int val;// 节点的值 ListNode * next;
单链表：删除区间元素
weixin_63381305的博客
09-19 1154
已知线性表中的元素是无序的，元素序列为（10，40，50，90，60，78，99，86，43，21），实现一个删除表中所有值小于max但大于min的元素算法，该线性表以带头结点的单链表的存储结构。
用单链表实现集合的并
魔鬼的归宿
11-29 1349
”光说不练假把式“ 先说一下，像数据结构这种理论与实践并重的课程，一定要实际操作一下才能深刻理解它的理论。 用单链表实现集合的 并 运算，声明一个并运算函数 Union(LinkList * ha, LinkList * hb, LinkList * &hc)； 之所以是  LinkList * &hc  是因为hc是用来存储并运算以后的元素，是一个新建的单链表，需要进行空间分配，
设计在链式存储结构上合并排序的算法
假技术Po主
09-27 3342
代码如下： void mergelklist(lklist *ha,lklist *hb,lklist *&hc) { lklist *s=hc=0; while(ha!=0 && hb!=0) { if(ha->data<hb->data) { if(s==0) { hc=s=ha; }else{ s-&g...
【C语言】知识点总结（链表）
qq_41684134的博客
09-06 3571
随时更 LinkList s = (LinkList)malloc(sizeof(LinkList)); LinkList ：用户自己定义的链表，是一个结构体，比如： typedef struct _LinkList { int id; // 学号 char name[16]; ...
单链表的建立(尾插法,头插法,链表的删除,链表的初始化)
qq_57484399的博客
09-30 1843
我们要建立单链表,那就需要有数据插入,所以我们先用链表结点的数据类型来定义一个数据,然后建立链表的时候,就可以从数据来获取数据了(数组也是指针类型,并且不可修改)存储数据的,带有指针的,单向指引的数据结构. 头结点一般是识别链表的,所以不包含数据,如果链表为空,那么头结点指向第一个节点的尾指针也是NULL.我们现在,就已经,定义出结点的数据和指针了,接下来的工作就是链表初始化,和链表的插入,输出,清空链表的操作了,我们一 一进行.ElemType a[8] = {1,2,3,4,5,6,7,8};
单链表的基本操作(C语言+图解分析)
Curz酥的博客
08-23 1538
纯C语言，代码均可直接运行，读者可自行调试。
python数据结构之链表详解
09-21
主要为大家详细介绍了python数据结构之链表的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
[数据结构]——链表详解
m0_62023005的博客
09-19 3743
数据结构---链表详解
[Python]数据结构--链表
Festinatione facit vastum
01-11 564
[Python]数据结构–链表 ‘Festinatione facit vastum’ 链表的概念 单链表的实现 循环单链表的实现 链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 15万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
【C语言数据结构（基础篇）】第三站：链表（一）
青色_忘川的博客
12-14 1524
本节讲解了单链表的实现
数据结构第二章关于Linklist *L,LInklist &L,Linklist L（指针在函数中的问题）
gsggd的博客
04-19 6380
在复习数据结构第二章的时候，总是搞不清楚什么时候该用指针，什么时候不该用指针，究其根本还是因为自己对于所要处理的变量的表达没有搞得太清楚。 首先来看链表的定义 typedef struct LNode{ int data; //数据域 struct LNode * next;//指针域 }* LinkList,LNode; 这里关于链表的结构体定义是*LinkList，即将LNode*重新命名为LinkList(理解为指向节点的指针的指针)。则LinkList L，是指向结构体（LN
LinkList *p与LinkList p区别
wh3165832165的博客
09-25 696
指针区别
2022/7/20数据结构——链表1
ad20001218的博客
07-20 308
链表的使用的练习
java数据结构链表详解
08-06
链表是一种常见的数据结构，用于存储一系列的元素。在Java中，链表可以使用LinkedList类来实现。下面是关于Java链表的详细解释： 链表由节点（Node）组成，每个节点包含两部分：数据域（存储元素的值）和指针域（指向下一个节点的指针）。链表的头节点是链表的起始点，尾节点是链表的结束点。 Java中的LinkedList类实现了List接口和Deque接口，因此可以用作列表和双端队列。LinkedList在内存中以链式结构存储元素，相邻元素通过节点的指针连接。 与数组相比，链表的一个优势是可以快速地插入和删除元素。由于链表中的元素在内存中不连续存储，所以插入和删除只需要改变指针的指向，而不需要移动其他元素。然而，链表的一个劣势是访问特定索引的元素比较慢，因为需要从头节点开始遍历链表。 下面是一些常用的操作示例： 1. 创建一个空链表： LinkedList<String> list = new LinkedList<>(); 2. 在链表末尾添加元素： list.add("A"); list.add("B"); list.add("C"); 3. 在指定位置插入元素： list.add(1, "D"); // 在索引为1的位置插入元素D 4. 获取链表的大小： int size = list.size(); 5. 获取指定索引位置的元素： String element = list.get(2); // 获取索引为2的元素 6. 修改指定索引位置的元素： list.set(0, "E"); // 将索引为0的元素修改为E 7. 删除指定索引位置的元素： list.remove(1); // 删除索引为1的元素 8. 遍历链表： for (String element : list) { System.out.println(element); } 需要注意的是，LinkedList类不是线程安全的，如果在多线程环境中使用链表，需要进行适当的同步处理。此外，由于链表中的元素不是连续存储，所以对于大量元素的访问和操作，可能会导致性能下降。在这种情况下，可以考虑使用ArrayList或其他更适合的数据结构。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值