单链表的实现

最新推荐文章于 2024-07-22 20:42:27 发布
最新推荐文章于 2024-07-22 20:42:27 发布
阅读量687 收藏 16
点赞数 35
文章标签： 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/unlockjy/article/details/137722481
版权

前言：

在之前我们实现了顺序表及其通讯录的实现，在实现的过程中我们可以发现空间会有一些浪费，比如说：中间，头部的插入或者删除，我们需要移动数据，时间复杂度为O（N），当空间不够时，我们需要使用realloc动态开辟内存，可能需要申请新的空间，拷贝数据，释放旧的空间，增容的新空间也会有一定的浪费。这些问题我们可以通过链表去解决！接下来就让我们来了解一下链表及其链表的实现。

主要常用的链表分为不带头单向不循环（单链表）和带头双向循环（双链表）

这里我们只介绍单链表

1.链表的概念：

  链表一种线性的数据结构，通过指针将一个个零散的内存块连接起来，链表的每个内存块称为结点。在逻辑结构上是线性的，在物理结构不一定是线性的。链表是由一个一个的节点组成，我们可以画图来理解一下链表!

我们可以发现每一个节点都由数据和指向下一个节点的指针两部分组成 ，这个时候我们就可以定义一个结构体来存放这两个数据！

2.实现链表所需文件

这里和我们实现顺序表一样需要三个文件

头文件:SListnode.h 声明链表结构 链表对应的接口声明

源文件：SListnode.c 实现函数  test.c 测试函数

3.链表结构的定义

链表的结构就是上述所说的数据+指向下一个节点的指针，这里就画图解释了。

3.单链表的尾插和头插 

3.1尾插

尾插就是在原链表的后面插入一个新的值，假设我们想要插入4，那我们需要建立一个newnode来存放我们的4，那就要申请一个节点的空间，这个节点存储的值就是4，那如何将他们连接起来呢？我们可以来画图分析一下！

当我们不管是进行尾插还是头插或者指定插入，我们都要向内存申请一块空间，这个时候我们就可以封装一个申请空间的函数，当想要使用申请空间的时候直接调用函数即可！

 接下来我们来实现一下尾插

尾插代码：

slistnode* SLTBuynode(SListnodeType x)
{
	slistnode* newnode = (slistnode*)malloc(sizeof(slistnode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
//尾插
void SLTPushBack(slistnode** pphead, SListnodeType x)
{
	assert(pphead);
	slistnode* newnode = SLTBuynode(x);
	//判空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		slistnode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		//ptail指向尾节点
		ptail->next = newnode;
	}
}

3.2头插 

头插就是将newnode放在最前面，也要把*pphead放在newnode的位置！

代码实现

//头插
void SLTPushFront(slistnode** pphead, SListnodeType x)
{
	assert(pphead);
	slistnode* newnode = SLTBuynode(x);
	//判空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//不为空
		newnode->next = *pphead;
		*pphead = newnode;
	}
}

 

4.单链表的打印

打印非常简单，我们只需要把链表遍历一遍，链表为结束，其余直接打印即可！

//链表的打印
void SLTprint(slistnode* phead)
{
	slistnode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

 5.单链表的尾删和头删

5.1尾删

尾删首先我们要找到尾节点，因为我们要释放掉尾节点，也要把尾节点的前驱节点的指向下一节点的地址设为NULL，不然就成为野指针了！

实现代码： 

//尾删
void SLTPopBack(slistnode** pphead)
{
	assert(pphead);
	//判断是否只有一个有效节点
	if ((*pphead) == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		slistnode* ptail = *pphead;
		slistnode* prev = *pphead;
		//找尾
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		//找到尾节点
		free(ptail);
		ptail == NULL;
		prev->next = NULL;
	}
}

5.2头删 

要先将第一个有效节点的下一个节点的地址存储起来，不然会找不到第二个有效的节点，也要注意断言确保有第一个有效节点！

实现头删 

//头删
void SLTPopFront(slistnode** pphead)
{
	assert(pphead && *pphead);
	slistnode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

6.单链表的查找 

链表的查找就是遍历一遍链表，找到返回，没有找到返回空！

代码实现：

//查找
slistnode* SLTFind(slistnode* phead, SListnodeType x)
{
	slistnode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}

7.单链表在指定位置之前和指定位置之后插入数据

7.1在指定位置之前位置插入数据

这里注意要注意传的地址不为NULL，链表也不可以为空以及pos也不能为空

代码实现：

//在指定位置之前插入
void SLTInsert(slistnode** pphead, slistnode* pos, SListnodeType x)
{
	assert(pphead && *pphead);
	assert(pos);
	slistnode* newnode = SLTBuynode(x);
	//如果pos=第一个有效节点 使用头插即可
	if (pos == *pphead)
	{
		SLTPopFront(pphead, x);
	}
	else
	{
		//找pos的前驱节点
		slistnode* pcur = *pphead;
		while (pcur->next != pos)
		{
			pcur = pcur->next;
		}
		//找到了
		newnode->next = pos;
		pcur->next = newnode;
	}
}

7.2在指定位置之后插入数据

这里注意也要进行断言！

 

 代码实现：

//在指定位置之后插入
void SLTInsertafter(slistnode** pphead, slistnode* pos, SListnodeType x)
{
	assert(pphead && *pphead);
	assert(pos);
	slistnode* newnode = SLTBuynode(x);
	slistnode* next = pos->next;
	pos->next = newnode;
	newnode->next = next;
}

 

8.单链表在指定位置删除

思路：首先断言进行判断，保证pphead，*pphead，pos的有效性，接下来要找pos的前驱节点，也要存储pos的下一个节点，然后将pos的前驱节点和pos的后一个节点连接起来，然后释放pos！

接下来给大家画图分析：

 代码实现：

//在指定位置删除
void SLTErase(slistnode** pphead, slistnode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		slistnode* perv = *pphead;
		slistnode* next = pos->next;
		while (perv->next != pos)
		{
			perv = perv->next;
		}
		//找到了
		perv->next = next;
		free(pos);
		pos = NULL;
	}
}

 9.单链表删除pos之后的节点

 10.单链表的销毁

当我们销毁链表，就是将一个一个的节点销毁掉!最后不要忘记要把*pphead设置为NULL

//链表的销毁
void SListDestroy(slistnode** pphead)
{
	assert(pphead && *pphead);
	slistnode* pcur = *pphead;
	while (pcur)
	{
		slistnode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//销毁完成
	*pphead = NULL;
}

让我们来调试观察一下

11.整体码源

SListnode.h

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

//链表结构定义
typedef int SListnodeType;
typedef struct SListnode
{
	SListnodeType data;
	struct SListnode* next;
}slistnode;


//打印
void SLTprint(slistnode* phead);

//尾插
void SLTPushBack(slistnode** pphead, SListnodeType x);

//头插
void SLTPushFront(slistnode** pphead, SListnodeType x);


//尾删
void SLTPopBack(slistnode** pphead);


//头删
void SLTPopFront(slistnode** pphead);

//查找
slistnode* SLTFind(slistnode* phead, SListnodeType x);

//在指定位置之前插入
void SLTInsert(slistnode** pphead, slistnode* pos, SListnodeType x);

//在指定位置之后插入
void SLTInsertafter(slistnode** pphead, slistnode* pos, SListnodeType x);

//在指定位置删除
void SLTErase(slistnode** pphead, slistnode* pos);

//在指定位置之后删除
void SLTEraseafter(slistnode* pos);

//链表的销毁
void SListDestroy(slistnode** pphead);

SListnode.c

#include"SListnode.h"

//链表的打印
void SLTprint(slistnode* phead)
{
	slistnode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}


slistnode* SLTBuynode(SListnodeType x)
{
	slistnode* newnode = (slistnode*)malloc(sizeof(slistnode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
//尾插
void SLTPushBack(slistnode** pphead, SListnodeType x)
{
	assert(pphead);
	slistnode* newnode = SLTBuynode(x);
	//判空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		slistnode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		//ptail指向尾节点
		ptail->next = newnode;
	}
}

//头插
void SLTPushFront(slistnode** pphead, SListnodeType x)
{
	assert(pphead);
	slistnode* newnode = SLTBuynode(x);
	//判空
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//不为空
		newnode->next = *pphead;
		*pphead = newnode;
	}
}

//尾删
void SLTPopBack(slistnode** pphead)
{
	assert(pphead);
	//判断是否只有一个有效节点
	if ((*pphead) == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		slistnode* ptail = *pphead;
		slistnode* prev = *pphead;
		//找尾
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		//找到尾节点
		free(ptail);
		ptail = NULL;
		prev->next = NULL;
	}
}

//头删
void SLTPopFront(slistnode** pphead)
{
	assert(pphead && *pphead);
	slistnode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}


//查找
slistnode* SLTFind(slistnode* phead, SListnodeType x)
{
	slistnode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}

//在指定位置之前插入
void SLTInsert(slistnode** pphead, slistnode* pos, SListnodeType x)
{
	assert(pphead && *pphead);
	assert(pos);
	slistnode* newnode = SLTBuynode(x);
	//如果pos=第一个有效节点 使用头插即可
	if (pos == *pphead)
	{
		SLTPopFront(pphead, x);
	}
	else
	{
		//找pos的前驱节点
		slistnode* pcur = *pphead;
		while (pcur->next != pos)
		{
			pcur = pcur->next;
		}
		//找到了
		newnode->next = pos;
		pcur->next = newnode;
	}
}

//在指定位置之后插入
void SLTInsertafter(slistnode** pphead, slistnode* pos, SListnodeType x)
{
	assert(pphead && *pphead);
	assert(pos);
	slistnode* newnode = SLTBuynode(x);
	slistnode* next = pos->next;
	pos->next = newnode;
	newnode->next = next;
}

//在指定位置删除
void SLTErase(slistnode** pphead, slistnode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		slistnode* perv = *pphead;
		slistnode* next = pos->next;
		while (perv->next != pos)
		{
			perv = perv->next;
		}
		//找到了
		perv->next = next;
		free(pos);
		pos = NULL;
	}
}


//在指定位置之后删除
void SLTEraseafter(slistnode* pos)
{
	assert(pos && pos->next);
	slistnode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

//链表的销毁
void SListDestroy(slistnode** pphead)
{
	assert(pphead && *pphead);
	slistnode* pcur = *pphead;
	while (pcur)
	{
		slistnode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//销毁完成
	*pphead = NULL;
}

test.c

#include"SListnode.h"

void slistnodetest()
{
	slistnode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SListDestroy(&plist);
	//SLTprint(plist);
	/*SLTPushFront(&plist, 1);
	SLTPushFront(&plist, 2);*/
	//SLTPopBack(&plist);
	//SLTPopFront(&plist);
	//SLTprint(plist);
	//slistnode* find = SLTFind(plist, 2);
	//if (find == NULL)
	//{
	//	printf("没有找到!\n");
	//}
	//else
	//	printf("找到了!\n");
	//SLTInsert(&plist, find, 9);
	//SLTInsertafter(&plist, find, 5);
	//SLTErase(&plist, find);
	//SLTEraseafter(find);
	//SLTprint(plist);
}

int main()
{
	slistnodetest();
	return 0;
}

 11.结语

这篇代码主要写了单链表的实现，接下来会实现单链表的通讯录项目，也会去实现双链表，都是有整体码源的，希望可以帮助到大家，大佬互三！！！

unlockjy
关注
  • 35
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单链表实现大整数相加
qq_62175345的博客
05-02 2127
C/C++语言中的int类型能表示的整数范围是-2^31~2^31-1,unsigned int类型能表示的整数范围是0~2^32-1, 即0~4 294 967 295，所以，int和unsigned int类型都不能存储超过10位的整数。有些问题需要处理的整数远远不止10位， 这种大整数用C/C++语言的基本数据类型无法直接表示。请编写算法，采用顺序表或者单链表实现两个大整数相加运算。 提示：将用户输入的十进制整数字符串转化为顺序表或者带头结点的单链表， 每个数据元素或每个结点中存放一个整数位，然...
单链表实现约瑟夫环
09-29
单链表解决约瑟夫环问题
用单链表实现栈
qq_51793991的博客
07-16 1113
用单链表实现栈的压栈和弹栈操作，栈是一种先进后出，后进先出的数据结构（类似弹夹），top节点指向栈第一个元素
对单链表实现就地逆置
qq_47991812的博客
11-27 3360
对单链表实现就地逆置 /* 对单链表实现就地逆置 */ #include <stdio.h> #include "malloc.h" typedef struct LNode{ int data; struct LNode *next; }LNode,*LinkList;//线性链表类型 //逆置 //先把头结点后一个结点i放在末尾，然后在之前末尾结点和当前末尾结点i之间插入结点如：1 2 3 4 -->2 3 4 1 --> 4 3 2 1 vo...
单链表实现简单选择排序
weixin_45278641的博客
07-29 4487
递增有序每次从原链表中找出一个最大(最小)元素，然后头插(尾插)到结果链表中。递减有序每次从原链表中找出一个最小(最大)元素，然后头插(尾插)到结果链表中。
单链表实现约瑟夫环问题
weixin_52596036的博客
09-07 3009
这两天想到了之前自己用数组实现约瑟夫环问题时写了好多的代码，然后想到数据结构中的但链表好像也可以实现，于是去实践了一下，发现果然可以实现，而且还代码还简洁明了不少。
如何使用单链表实现队列
超烦豆先森
11-18 1045
java代码 使用单链表来实现队列
单链表实现多项式相加
qq_44886213的博客
04-30 3589
一、题目 依次输入两个多项式的项数，然后输入每一项的系数和指数，用空格隔开。 结果给出两个多项式相加的系数和指数。 二、解析 思路： （1）结构体包括三部分，系数、指数和next指针 （2）写一个创建单链表的函数，先询问用户多项式的项数，然后从首元结点开始依次存储每一项的系数和指数 （3）我用链表a去存储结果。两链表a,b比较时，需要三个指针。anow指向链表a当前需要比较的结点，bnow指向链表b当前需要比较的结点，因为后面的分析中需要用到前插法将结点插入a中，所以还需要anow的前驱结点apre。 （4
【Java】使用单链表实现栈
Jaye513的博客
11-27 805
单链表又一新玩法，还不冲？
利用单链表实现逆序输出
hnjzsyjyj的专栏
09-14 3296
【原理：利用头插法建立单链表后，若从头指针访问，其输出的结点次序与建单链表时输入的结点次序恰好相反。故利用单链表的这个特性，可完美实现逆序输出。
用单链表实现学生信息管理系统
热门推荐
温泉
03-24 3万+
用单链表实现学生信息管理系统 问题描述 定义一个包含学生信息（学号，姓名，成绩）的的顺序表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； (5) 给定一个学生信息，插入到表中指定的位置； (6) 删除指定位置的学生记...
C语言单链表实现方法详解
08-27
C语言单链表实现方法详解 单链表是一种基本的数据结构，在C语言中实现单链表可以提高程序的效率和灵活性。本文将详细介绍C语言单链表的实现方法，包括单链表的定义、创建、添加、删除、排序、打印等操作技巧，并...
单链表实现
08-07
在本主题中，我们将深入探讨单链表的实现，包括其基本操作、优缺点以及在实际编程中的应用。 单链表的每个节点通常包含两部分：数据域和指针域。数据域存储实际的数据，而指针域存储指向下一个节点的引用。链表的第...
C语言单链表实现多项式相加
08-29
C语言单链表实现多项式相加 多项式是数学中的一种重要概念，表示为一个变量的幂的和。多项式相加是指将两个或多个多项式进行加法运算，结果仍然是一个多项式。在计算机科学中，实现多项式相加需要使用数据结构和...
C语言单链表实现
01-16
单链表是计算机科学中数据结构的基础之一，它在C语言中的实现对于理解和掌握数据结构的概念至关重要。在本文中，我们将深入探讨C语言如何通过结构体和指针来实现单链表。 首先，我们需要理解单链表的基本概念。...
IO多路复用-select的使用详解【C语言】
qq_42037383的博客
07-21 898
IO多路转接也称为IO多路复用，它是一种网络通信的手段（机制），通过这种方式可以同时监测多个文件描述符并且这个过程是阻塞的，一旦检测到有文件描述符就绪（ 可以读数据或者可以写数据）程序的阻塞就会被解除，之后就可以基于这些（一个或多个）就绪的文件描述符进行通信了。通过这种方式在单线程/进程的场景下也可以在服务器端实现并发。常见的IO多路转接方式有：select、poll、epoll。
C语言——字符串中sizeof和strlen的辨析
weixin_45720999的博客
07-19 393
在C语言中，sizeof 和 strlen 函数在处理字符串时有明显不同的作用和结果。使用不当很容易出现错误......
【C语言】 约瑟夫环，循环链表实现
最新发布
2301_77133426的博客
07-22 101
1、循环链表实现约瑟夫环，每次经过特定步数删除一个元素
c语言（7.22）
fhgfyrsg的博客
07-22 380
在7，23，79，81，103，127，131，147中查找数据*/核心思路：就是从数组的0索引开始，依次往后查找，如果找到了，就会返回数据对应的索引。如果没有找到，就会返回-1。//不是用mid和num进行比较。//2.定义变量表示要查找的数据。//2，定义一个要查的数据。/*需求：数组的二分查找。//mid应该放在循环里面。/* 需求：数组的基本查找。
单链表实现与操作详解
在实现单链表时，通常会引入一个头结点，即使得链表的头部有一个特殊的节点，它的主要作用是在链表头部进行插入和删除操作时提供便利。头结点的数据域通常不存储实际数据，而其指针域指向链表的第一个数据节点。在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值