单链表的实现

已于 2024-08-05 21:35:41 修改
阅读量758 收藏 12
点赞数 14
分类专栏： 数据结构 文章标签： c语言 数据结构 算法
于 2024-08-04 13:39:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zach_yuan/article/details/140894195
版权

文章目录

引入

YY：顺序表的插入和删除都好麻烦哦，有没有啥简单的方法来实现呀？
当然有啦，单链表这不就来了嘛

链表的概念

单链表是链表的一个分支，我们先来看一下链表的概念
链表：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
解释：如果把顺序表比作是高楼大厦的话，那么链表就好比是小火车，小火车的每节车厢之间本身是没有关系的，而是通过一个个的挂钩，把每节车厢链接起来

单链表的声明

链表是由结点构成的，结点包括数据域和指针域，数据域用来存储数据，指针域用来链接逻辑结构相邻的结点

typedef int SLTDataType;
typedef struct SingleLinkListNode
{
	SLTDataType data;
	struct SingleLinkListNode* next;
}SLTNode;

初始化单链表

void createSList()
{
	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
	node1->data = 1;
	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
	node2->data = 2;
	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
	node3->data = 3;
	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
	node4->data = 4;

	node1->next = node2;
	node2->next = node3;
	node3->next = node4;
	node4->next = NULL;
}

打印单链表

void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

这里特意的创建了一个新的变量pcur,目的是保留传入指针指向的位置，是良好的编程习惯

增加结点

SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	node->data = x;
	node->next = NULL;
	return node;
}

动态申请内存，并且判断是否成功开辟空间，返回值是开辟结点的地址

单链表尾插

void SLTPushBake(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* pcur = *pphead;
		while (pcur->next)
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;
	}
}
  • 因为这里要改变链表的内容，所以要进行传址调用，又由于头结点本身就是一个指针，所以这里用到二级指针来接受头结点指针的地址，并通过解引用来访问该地址
  • 先调用SLTBuyNode开辟空间，特殊情况是当头结点为空，此时要单独处理，直接把新申请的结点赋值给头结点
  • 若头结点不为空则要找到尾结点，并且改变尾结点的指针域，使其指向新申请的newnode
  • 别忘记了 使用结构体指针的目的是能够动态的开辟内存空间，减少空间浪费，在动态顺序表中就已经体现

YY:**pphead和*pphead都是啥啊
创建单链表的第一步是创建一个头指针，就像这样

SLTNode* phead = NULL;

他是一个结构体类型的指针，指向的结构体就是咱们定义的结点，由于我们要对链表的内容来进行修改，这里就不能只是简单的传值调用，因为传值调用时，形参是实参的一份临时拷贝，对形参的操作，不会影响实参，而是要通过传址调用，来找到形参的地址，直接对形参进行操作
在参数中的**pphead是用来接收头指针的地址，而在代码块中*pphead是对pphead解引用找到了pphead所指向的空间

单链表头插

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

记着要移动头结点的位置

单链表尾删

void SLTPopBake(SLTNode** pphead)
{
	assert(pphead && *pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* ptail = *pphead;
		SLTNode* prev = NULL;//ptail就比prev多走一步
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		prev->next = NULL;
	}
}
  • 断言，防止传入空指针以及链表为空的情况
  • 当链表中只有一个结点时要特殊处理
  • ->操作符的优先级比*操作符的优先级高，因此要加括号
  • 尾删时影响的是最后一个结点，和最后一个结点之前的结点，因此要专门创建prev变量，将其指针域置为空

单链表头删

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}
  • 记录头结点的下一个结点
  • 删除头结点
  • 移动头结点

单链表结点查找

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);
	SLTNode* pcur = phead;
	while (pcur->next)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

找到则返回结点地址，未找到则返回NULL

在指定位置之前插入

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}
  • 若插入的位置是头指针，则相当于头插，要特殊处理
  • 重点关注插入过程中，结点之间的重新链接

在指定位置之后插入

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

参数部分不需要传入头指针的地址，因为不需要向前查找

指定位置删除

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
  • 如果删除的位置为头指针指向的位置，则相当于头删，要特殊处理
  • 找到pos之前的结点，使其的next链接pos的下一个结点
  • 释放pos，并置空

指定位置之后删除

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

指定位置pos链接os->next->next

销毁链表

void SListDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

源码

SList.h

#define  _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

//链表的结点的声明
typedef int SLTDataType;
typedef struct SingleLinkListNode
{
	SLTDataType data;
	struct SingleLinkListNode* next;
}SLTNode;

//打印链表
void SLTPrint(SLTNode* phead);

//增加新节点
SLTNode* SLTBuyNode(SLTDataType x);

//尾插
void SLTPushBake(SLTNode** pphead, SLTDataType x);

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);

//尾删
void SLTPopBake(SLTNode** pphead);

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

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

//指定位置之前插入
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

//指定位置之后插入
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

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

//指定位置之后删除
void SLTEraseAfter(SLTNode* pos);

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

SList.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

void SLTPrint(SLTNode* phead)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;
	}
	printf("NULL\n");
}

SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* node = (SLTNode*)malloc(sizeof(SLTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(1);
	}
	node->data = x;
	node->next = NULL;
	return node;
}

void SLTPushBake(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* pcur = *pphead;
		while (pcur->next)
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;
	}
}

void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SLTPopBake(SLTNode** pphead)
{
	assert(pphead && *pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* ptail = *pphead;
		SLTNode* prev = NULL;
		while (ptail->next)
		{
			prev = ptail;
			ptail = ptail->next;
		}
		free(ptail);
		ptail = NULL;
		prev->next = NULL;
	}
}

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);
	SLTNode* pcur = phead;
	while (pcur->next)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* newnode = SLTBuyNode(x);
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}

void SListDestroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

test.c

#define  _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

//void createSList()
//{
//	SLTNode* node1 = (SLTNode*)malloc(sizeof(SLTNode));
//	node1->data = 1;
//	SLTNode* node2 = (SLTNode*)malloc(sizeof(SLTNode));
//	node2->data = 2;
//	SLTNode* node3 = (SLTNode*)malloc(sizeof(SLTNode));
//	node3->data = 3;
//	SLTNode* node4 = (SLTNode*)malloc(sizeof(SLTNode));
//	node4->data = 4;
//
//	node1->next = node2;
//	node2->next = node3;
//	node3->next = node4;
//	node4->next = NULL;
//	SLTPrint(node1);
//}

void SListTest01()
{
	SLTNode* phead = NULL;
	//SLTPushBake(&phead, 1);
	//SLTPushBake(&phead, 2);
	//SLTPushBake(&phead, 3);
	//SLTPushBake(&phead, 4);
	//SLTPrint(phead);
	SLTPushFront(&phead, 1);
	SLTPushFront(&phead, 2);
	SLTPushFront(&phead, 3);
	SLTPushFront(&phead, 4);
	SLTPrint(phead);
	//SLTPopBake(&phead);
	//SLTPrint(phead);
	//SLTPopBake(&phead);
	//SLTPrint(phead);
	//SLTPopBake(&phead);
	//SLTPrint(phead);
	//SLTPopBake(&phead);
	//SLTPrint(phead);
	SLTPopFront(&phead);
	SLTPrint(phead);
	SLTNode* find = SLTFind(phead, 3);
	if (find == NULL)
	{
		printf("未找到！\n");
	}
	else
	{
		printf("找到啦！\n");
	}

	SLTInsert(&phead, find, 4);
	SLTPrint(phead);

	SLTInsertAfter(find, 9);
	SLTPrint(phead);

	//SLTErase(&phead, find);
	//SLTPrint(phead);

	SLTEraseAfter(find);
	SLTPrint(phead);

	SListDestroy(&phead);
	SLTPrint(phead);
}
int main()
{
	//createSList();
	SListTest01();
	return 0;
}

总结

以上是数据结构中单链表的相关知识，我们要像捡贝壳一样捡到自己的小篮子里哦，有不明白的地方欢迎留言，作者水平有限，文章不妥部分还请各位读者指正。

Zach_yuan
关注
  • 14
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表实现大整数相加
qq_62175345的博客
05-02 2149
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++语言的基本数据类型无法直接表示。请编写算法，采用顺序表或者单链表实现两个大整数相加运算。 提示：将用户输入的十进制整数字符串转化为顺序表或者带头结点的单链表， 每个数据元素或每个结点中存放一个整数位，然...
如何使用单链表实现队列
超烦豆先森
11-18 1067
java代码 使用单链表来实现队列
用单链表实现栈
qq_51793991的博客
07-16 1154
用单链表实现栈的压栈和弹栈操作，栈是一种先进后出，后进先出的数据结构（类似弹夹），top节点指向栈第一个元素
对单链表实现就地逆置
qq_47991812的博客
11-27 3380
对单链表实现就地逆置 /* 对单链表实现就地逆置 */ #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 4636
递增有序每次从原链表中找出一个最大(最小)元素，然后头插(尾插)到结果链表中。递减有序每次从原链表中找出一个最小(最大)元素，然后头插(尾插)到结果链表中。
单链表实现约瑟夫环问题
weixin_52596036的博客
09-07 3126
这两天想到了之前自己用数组实现约瑟夫环问题时写了好多的代码，然后想到数据结构中的但链表好像也可以实现，于是去实践了一下，发现果然可以实现，而且还代码还简洁明了不少。
【Java】使用单链表实现栈
Jaye513的博客
11-27 837
单链表又一新玩法，还不冲？
单链表实现多项式相加
qq_44886213的博客
04-30 3628
一、题目 依次输入两个多项式的项数，然后输入每一项的系数和指数，用空格隔开。 结果给出两个多项式相加的系数和指数。 二、解析 思路： （1）结构体包括三部分，系数、指数和next指针 （2）写一个创建单链表的函数，先询问用户多项式的项数，然后从首元结点开始依次存储每一项的系数和指数 （3）我用链表a去存储结果。两链表a,b比较时，需要三个指针。anow指向链表a当前需要比较的结点，bnow指向链表b当前需要比较的结点，因为后面的分析中需要用到前插法将结点插入a中，所以还需要anow的前驱结点apre。 （4
利用单链表实现逆序输出
hnjzsyjyj的专栏
09-14 3318
【原理：利用头插法建立单链表后，若从头指针访问，其输出的结点次序与建单链表时输入的结点次序恰好相反。故利用单链表的这个特性，可完美实现逆序输出。
用单链表实现学生信息管理系统
热门推荐
温泉
03-24 3万+
用单链表实现学生信息管理系统 问题描述 定义一个包含学生信息（学号，姓名，成绩）的的顺序表，使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据姓名进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）； (5) 给定一个学生信息，插入到表中指定的位置； (6) 删除指定位置的学生记...
单链表实现约瑟夫环
09-29
单链表解决约瑟夫环问题
利用带头结点的单链表实现两个集合的并、交、差运算.docx
04-19
利用带头结点的单链表实现两个集合的并、交、差运算 本文档的主要内容是使用带头结点的单链表实现两个集合的并、交、差运算。该文档共分为八个部分，分别是题目重述、题目功能描述、概要设计图、程序源代码及注释、...
单链表实现双向循环链表_链表_
09-29
单链表实现双向循环链表单向链表存在一个弊端就是，当需要获取某个结点p的前驱时，需要从头指针开始遍历链表，获得“前驱”的执行时间为O(n)，为了克服单向链表的这种缺点，可以利用双向链表。在双向链表中有两个...
单链表实现的多项式运算.cpp
03-25
利用单链表的数据结构，在读取数据时就按指数次方排序好，再加法的运算中可以直接按指数的大小进行运算，相比随机的读入数据，这个方法优化了程序。乘法则是在加法的基础上把每一项的系数进行相乘并最后求和。注意...
c语言单链表实现通讯录，支持保存数据到文件加载数据到文件
04-05
以上是C语言单链表实现通讯录的主要知识点，这些概念和操作对于理解和实现任何动态数据结构都是至关重要的。通过这个项目，我们可以学习到如何有效地管理内存，以及如何在程序中持久化数据。同时，它也提供了一个...
C/C++控制台贪吃蛇游戏的实现
fzy20110826的博客
08-20 2996
本文对给定的贪吃蛇游戏代码进行详细分析。该游戏使用 C++语言编写，通过控制台界面实现了经典的贪吃蛇游戏玩法，包括登录、注册、游戏介绍、游戏操作和计分等功能。
c/c++基础及类和对象汇总
最新发布
2301_77479435的博客
08-27 1143
c/c++基础及类和对象汇总
20240824给飞凌OK3588-C的核心板刷Ubuntu22.04并连接adb
南岭笑笑生之家
08-24 1005
缘起，由于我司对面积有极度的追求，所以将飞凌OK3588-C开发板使用的【9线+】type-C接口（USB3.1?）降级为4线的USB2.0。当然你有能力的话，貌似可以把需要安装的软件直接打包到Ubuntu22.04的文件系统中。2、通过USB数据线链接到你的电脑。如果连接不上，多插拔几次USB数据线，重启 飞凌OK3588-C的核心板 也是可选项！3、给飞凌OK3588-C的核心板 安装 ADB。
C语言 | Leetcode C语言题解之第377题组合总和IV
m0_59237910的博客
08-27 546
C语言 | Leetcode C语言题解之第377题组合总和IV
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值