数据结构—单链表

最新推荐文章于 2023-08-05 15:57:39 发布
最新推荐文章于 2023-08-05 15:57:39 发布
阅读量584 收藏 6
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43850474/article/details/101425795
版权

一、链表

（1）定义：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链。
（2）链表的基本知识

链表是一种动态的存储结构，所谓动态就是可以根据表中结点的个数来自动的分配合适的空间。也就是说，当插入结点时，系统自动申请一块空间，进行插入；当删除结点时，系统自动回收该结点所占用的空间，从而避免了空间的浪费。

链表在物理位置上并不相邻，但是在逻辑上是相邻的。

（2）链表的结构
  1. 带头、不带头
  2. 单向、双向
  3. 循环、非循环

将他们组合起来就有8种链表结构：带头单向循环链表、带头单向非循环链表、带头双向循环链表、带头双向非循环链表、不带头单向循环链表、不带头单向非循环链表、不带头双向循环链表、不带头双向非循环链表。

我们通常所说的单链表就是带头单向非循环链表

（3）链表的优缺点

二、单链表

单链表的结构

在这里插入图片描述
解析：

  1. 其中head表示的是头结点，一般来说头结点不用来存放信息，它可以看做单链表的入口地址，关于链表的所有的操作都是从头结点开始的，它指向的是链表中的第一个结点。

  2. 单链表中的每一个结点都由两部分组成。其中表示数据元素的部分叫做数据域，也就是A、B、C等具体的数据；表示直接后继的部分叫做指针域，它里面存放的是下一个结点的地址。

  3. 注意：最后一个结点的指针域一定要置为空。

三、单链表主要操作的实现

（1）插入操作
1. 头插：
将新结点插入到链表的第一个位置，换句话说，就是将新结点插入到head结点之后

如下图所示：
在这里插入图片描述
过程：

  1. 将新结点p连接到原先第一个结点之前
    p->next=head->next
  2. 将结点p连接到头结点之后
    head->next=p

注意：这个顺序不能弄反。

代码如下

void ListLink_InsertHead(LNode* head,DataType data)
{
	LNode* p;                                       
	p = (LNode*)malloc(sizeof(LNode));                
	p->data = data;
	p->next = head->next;         
	head->next = p;                         
}

2. 尾插： 将新结点插入到最后一个结点的后面
如下图所示：
在这里插入图片描述
过程：

  1. 找到最后一个结点（通过遍历）
  2. 将新结点连接到最后一个结点后面
  3. 新结点的next置为空

代码如下

void ListLink_InsertTail(LNode* head,DataType data)
{
	LNode* p;                     //代替head的作用
	LNode* q;                     //要插入的新节点
	q= (LNode*)malloc(sizeof(LNode));
	q->data = data;
	q->next = NULL;
	p = head;
	while (p->next != NULL)        //这个循环是为了找到最后一个结点
	{
		p = p->next;
	}
	//将新结点从最后一个结点后面插入
	p->next = q;
}

3. 随意插入： 在第i个位置处插入（包括第一个和最后一个位置）
如下图所示：
在这里插入图片描述

过程：

  1. 找到第i-1个结点
  2. 将第i个结点连接到新结点的后面
  3. 将新结点连接到第i-1个结点的后面

代码如下：

void ListLink_Insert(LNode* head, DataType data,DataType i)         //其中这个i是要插入的位置      
{
	LNode* p;                 
	p = head;
	LNode* q;                               //要插入的新节点
	q = (LNode*)malloc(sizeof(LNode));
	q->data = data;
	q->next = NULL;
	int j = 0;

	while (p->next != NULL && j < i - 1)
	{
		j++;
		p = p->next;                        //循环完毕后，p是第i-1个结点
	}

	q->next = p->next;                      //将第i个结点连接到新结点的后面
	p->next = q;                            //将新结点连接到第i-1个结点的后面
}

（2）删除操作
1. 头删： 删除链表的第一个结点
如下图所示：

在这里插入图片描述

过程：

  1. 先将第二个结点连接到头结点之后
  2. 再释放第一个结点

代码如下：

void ListLink_DeleteHead(LNode* head)
{
	LNode* p;                              //p是要删除的结点
	if (ListLink_IsEmpty(&L) == -1)         //删除之前首先要判空，判空函数会在下面写到
		return;
	p = head->next;
	head->next = p->next;
	free(p);
}

2. 尾删： 删除链表中最后一个元素
如下图所示：
在这里插入图片描述

过程：

  1. 找到倒数第二个结点
  2. 释放最后一个结点
  3. 将原倒数第二个结点的next置为空

代码如下：

void ListLink_DeleteTail(LNode* head)
{
	if (ListLink_IsEmpty(&L) == -1)         //删除之前首先要判空
		return;
	LNode* p,*q;
	p = head;
	while (p->next->next!= NULL)          //循环结束后，p是倒数第二个结点
	{
		p = p->next;              
	}
	q = p->next;                                   //q是最后一个结点
	free(q);
	p->next = NULL;
}

3. 随意删除： 删除第i个结点（包括头删和尾删）
如下图所示：
在这里插入图片描述

过程：

  1. 找到第i-1个结点
  2. 将第i+1个结点连接到第i-1个结点后面

代码如下：

void ListLink_delete(LNode* head,DataType i)
{

	LNode* p,*q;
	DataType j = 0;
	p = head;
	while (j < i - 1 && p->next != NULL)
	{
		j++;
		p = p->next;               //p是第i-1个元素
	}
	q = p->next;                   //q是第i个元素
	p->next = q->next;             //当q是最后一个结点时，q->next==NULL
	free(q);                  
}

四、完整的单链表的实现

上面所说的主要操作是单链表中比较难的部分，所以我将他们单独拿出来进行主要的讲解。但是一个单链表并不仅仅只是刚才所将的几个操作，只是其他操作较为简单，所以就不进行过多的叙述。只是在代码中进行适当的解释。

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
typedef int DataType;

struct Node                      //这个结构体定义的链表中各个节点的类型
{
	DataType data;             //数据域
	struct Node* next;         //指针域
}L;								//结构体变量


typedef struct Node LNode;       

//链表的初始化其实就是将链表置为空
void ListLink_Init(LNode* head)
{
	head->next == NULL;
}

//判断链表是否为空
DataType ListLink_IsEmpty(LNode* head)
{
	if (head->next == NULL)         //如果链表中是空的就返回-1，否则返回1
		return -1;
	else
		return 1;
}

//头插:只从头部插入,也就是插入到第一个位置
void ListLink_InsertHead(LNode* head,DataType data)
{
	LNode* p;                                       
	p = (LNode*)malloc(sizeof(LNode));                
	p->data = data;
	p->next = head->next;         
	head->next = p;                         
}
//尾插
void ListLink_InsertTail(LNode* head,DataType data)
{
	LNode* p;                   //代替head的作用
	LNode* q;                   //要插入的新节点
	q= (LNode*)malloc(sizeof(LNode));
	q->data = data;
	q->next = NULL;
	p = head;
	while (p->next != NULL)      //这个循环是为了找到最后一个结点
	{
		p = p->next;
	}
	//将新结点从最后一个结点后面插入
	p->next = q;
}

//插入：从第i个位置上插入结点（任意位置插入）

void ListLink_Insert(LNode* head, DataType data,DataType i)         //其中这个i是要插入的位置      
{
	LNode* p;                   
	p = head;
	LNode* q;                   //要插入的新节点
	q = (LNode*)malloc(sizeof(LNode));
	q->data = data;
	q->next = NULL;
	DataType j = 0;

	while (p->next != NULL && j < i - 1)
	{
		j++;
		p = p->next;                          //循环完毕后，p是第i-1个结点
	}

	q->next = p->next;
	p->next = q;
}

//头删:删除第一个结点
void ListLink_DeleteHead(LNode* head)
{
	LNode* p;
	if (ListLink_IsEmpty(&L) == -1)         //删除之前首先要判空
		return;
	p = head->next;
	head->next = p->next;
	free(p);
}
//尾删
void ListLink_DeleteTail(LNode* head)
{
	if (ListLink_IsEmpty(&L) == -1)         //删除之前首先要判空
		return;
	LNode* p,*q;
	p = head;
	while (p->next->next!= NULL)          //循环结束后，p是倒数第二个结点
	{
		p = p->next;              
	}
	q = p->next;                          //q是最后一个结点
	free(q);
	p->next = NULL;
}

//删除：删除第i个位置的结点（任意位置删除）

void ListLink_delete(LNode* head,DataType i)
{

	LNode* p,*q;
	DataType j = 0;
	p = head;
	while (j < i - 1 && p->next != NULL)
	{
		j++;
		p = p->next;
	}
	q = p->next;                 //q是第i个元素
	p->next = q->next;
	free(q);                   //当q是最后一个结点时，q->next==NULL
}
//根据位置查找：查找第i个结点，并且返回第i个结点
LNode* ListLink_FindLocate(LNode* head, DataType i)
{

	LNode* p;
	p = head;
	DataType j = 0;
	while (j < i && p->next != NULL)
	{
		j++;
		p = p->next;
	}
	return p;
}

//根据数字查找，返回与指定数字相同的结点
LNode* ListLink_FindFigure(LNode* head, DataType data)
{
	LNode* p;
	p = head->next;
	while (p != NULL)
	{
		if (p->data == data)
		{
			return p;
		}
		p = p->next;
	}
}

//销毁链表（包括头结点在内的所有结点）
//从头结点开始依次释放
void ListLink_Destory(LNode* head)
{
	LNode* p;
	while (head->next != NULL)
	{
		p = head;
		head = head->next;
		free(p);
	}
}

//求链表的长度
DataType ListLink_GetLength(LNode* head)
{
	LNode* p;
	DataType count = 0;
	p = head->next;
	while (p != NULL)
	{
		count++;
		p = p->next;
	}
	return count;
}
//输出链表中的每一个结点
void ListLink_Display(LNode* head)
{
	LNode* p;
	p = head->next;
	while (p != NULL)
	{
		printf("%d  ", p->data);
		p = p->next;
	}
}

//在main函数中给出一些具体的调用，这样大家知道如何使用这些函数
int main()
{
	ListLink_Init(&L);
	ListLink_InsertHead(&L, 3);
	ListLink_InsertHead(&L,5);
	ListLink_InsertHead(&L,7);
	ListLink_InsertHead(&L, 1);
	ListLink_InsertHead(&L, 39);

	ListLink_InsertTail(&L, 32);

	ListLink_Display(&L);

	system("pause");
	return 0;
}

五、小技巧

  1. 对链表进行遍历时，如果p指向的是头结点，那么while循环结束的标志是
    p->next!=NULL，并且当遍历结束时，此时的p指向的是最后一个结点
p=head;
while(p->next!=NULL)
{
	p=p->next;
}
  1. 对链表进行遍历时，如果p指向的是第一个结点，那么while循环结束的标志是
    p!=NULL，并且当遍历结束时，此时的p指向的是最后一个结点的后面一个不知道的空间
p=head->next;
while(p!=NULL)
{
	p=p->next;
}
  1. 在链表中只要要找第i-1个结点，代码其实是固定的
//第一种：当p=head时
int j=0;
p=head;
while(p->next!=NULL && j<i-1)
{
	j++;
	p=p->next;                   //循环完毕后p是第i-1个结点
}

//第二种：p=head->next
int j =0；
p=head->next;
while(p!=NULL && j<i-1)
{
	p=p->next;
	j++;
}
镜中月ss
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
单链表 基本操作（元素递增排序）
菇凉小伙de博客
10-08 8122
题目描述： 有一个带头节点的单链表L(至少有一个数据节点），设计一个算法使其元素递增有序排列。 解题思路： 由于单链表L中有一个以上的数据节点，首先构造一个只含有头结点和首节点的有序单链表（只含有一个数据节点的单链表一定是有序的），然后扫描单链表L余下的节点（由P指向），在有序单链表中通过比较找插入节点P的前驱节点（由pre指向它），在pre节点之后插入P节点，知道P==NULL为止（这里实...
数据结构与算法学习笔记（三）单向链表
叶阳洋的博客
07-27 1526
一. 几个概念 0x01 链表   链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针连接次序实现的。链表是以结点的方式存储的，是链式存储。结点可以在运行时动态生成。链表是有序的列表，但其在内存中的存储是非连续、非顺序的。 0x02 结点   在链表数据结构中，我们把一个数据元素的存储映像称为结点（Node）。而一个结点包含存储数据元素的两部分信息：数据域（Data）和指针域(Next)。 0x03 数据域、指针域 数据域：存储数据元素信息的域； 指针域：存储直接后继位置
初阶数据结构——顺序表和链表(单链表)
Adz1119的博客
04-28 737
初阶数据结构——顺序表和链表
单链表基本功能解读
qq_52777887的博客
03-03 880
前言 小伙伴们大家好，前面的文章对于顺序表我们做了一定的分析。但是我们发现，其实顺序表有一定缺陷的： 首先就是开辟的空间可能用不完，会造成空间浪费； 其次就是头部或者中间的插入删除时间复杂度是O(N)，所以我们认为对于顺序表而言，有些时候我们不应该用它，而是用一种没有以上缺陷的顺序表。 再者就是增容的时候申请空间，资源拷贝，然后释放空间会有一定的消耗。 那么其实，在线性表中有这样一种结构，它的物理地址是“依次链接”的，而且每个元素在内存中都是随机存放的，如果我们需要新增元素的话，只需要将该元素
【数据结构与算法】单链表的排序算法(选择，冒泡，递归）
摸鱼小小虫的博客
11-27 5703
链表的选择排序思想与数组的排序类似，但是链表需要先找到里面最小或者最大的值，然后将这个值用改链语句进行操作。接下来我们进行排序，首先选取一个基准点，如何将比基准点大/小的值放左边，比基准点小/大的放右边。我们先看这个改链语句的操作（min是笔者打错了应该是max，但是图已经画好了就没有改）移动q这个指针找到最大的min，然后利用i保存q的前一个节点这样就能找到min_on.数组快速排序的思想和链表的一样，主要问题就是存在改链的操作。然后我们就可以将链表进行排序了，完整的代码如下。此时我们将2下沉到底部；
链表结点的物理顺序与逻辑顺序
TearjerkerR的博客
06-19 2711
题目描述已知一个单向链表各结点在存储器中的物理顺序，以及各结点之间的指向关系，要求输出该链表各结点的逻辑顺序。 如图所示的链表，共有6个结点，按这6个结点在存储器中的物理顺序依次编号为1～6。第1个结点的指针域为p4，表示它指向第4个结点。在该图中，符号“∧”表示空指针。因此，这个链表6个结点的逻辑顺序为：6-&gt;1-&gt;4-&gt;2-&gt;5-&gt;3。输入输入文件中包含多个测试数...
数据结构 c 语言 线性子列表
qq_45728434的博客
10-14 1106
实验内容： 用结构体描述一个字符型单链表；创建线性表；在线性表中插入元素，删除元素，显示线性表中所有的元素；用if语句设计一个选择式菜单。 代码： #include<stdio.h> #include<stdlib.h> typedef struct node{ int elem; struct node *next; }NODE,*PNODE; void create(PNODE &head,int n){ PNODE p; head = (PNODE)mallo
【数据结构】单链表（带图详解）
Z1tai的博客
05-12 9552
概念：链表是一种物理存储结构上非连续非顺序的存储结构，但链表在逻辑上是连续的，顺序的，而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。
数据结构单链表制作QQ名片最终稿
04-27
绝对干货直接就是源代码 采用顺序表，设计一个QQ群名片，主要包含：QQ号码、昵称、性别、年龄、生日等属性。完成基本功能如下： （1）初始化群名片； （2）添加某一个QQ群中10名成员的名片信息；...
数据结构 单链表 约瑟夫问题
08-27
数据结构 单链表 约瑟夫问题
数据结构单链表
01-08
数据结构的一些讲解，供学习者参考，也顺带作为复习需要源代码的欢迎下载，免积分，共同学习，家下来每天都会分享一篇，持续一个星期
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
C语言数据结构单链表的增删查改
最新发布
04-29
C语言数据结构单链表的增删查改
数据结构单链表的详细介绍
09-03
本资源以实验报告形式详细介绍了单链表的建立，查找，删除，长度，遍历，销毁，并提供源码
【数据结构】单链表超详细解析 | 从零开始步步解读 | 画图理解
⚡ 柠檬叶子团队
11-03 1964
本章节将对链表的概念进行介绍，着重讲解单顺序表。对常用的接口函数进行一个个讲解，并进行解析，单链表表讲解部分将从零实现常见单链表接口函数。
数据结构-（单链表篇）
B_Small_panda的博客
01-16 977
数据结构-（单链表篇）
数据结构--带头结点的单向链表
散步的呆头鹅的博客
08-05 2025
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。
数据结构：链表与逻辑问题
Kobe51920的博客
08-18 2688
优点 缺点 链表 1.用多少开多少，直接链上去，没有空间浪费 2.头尾插入效率高 O(1) 不支持随机访问，顺序访问 顺序表 1.支持随机访问,随机访问 1.增容时成倍增长，有空间浪费 2.中间或者头部插入数据时效率不高 O(N) ...
c语言数据结构单链表长度
03-27
C语言数据结构单链表长度可以通过遍历单链表来计算。具体实现方法如下： 1. 定义一个变量count，用于记录单链表长度，初始值为0。 2. 从单链表的头节点开始，依次遍历单链表的每个节点，每遍历一个节点，count的值...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值