单链表及其代码实现

最新推荐文章于 2024-10-04 18:59:43 发布
最新推荐文章于 2024-10-04 18:59:43 发布
阅读量858 收藏 16
点赞数 13
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74328241/article/details/142527097
版权

目录

前言

本文介绍单链表，主要是创销、增删改查代码实现。
注：文章中函数命名采取STL库。

单链表

1.1 单链表的定义

单链表是链线性表的一种，线性表是一种逻辑结构，根据不同的物理（存储）结构即顺序存储和链式存储，分为顺序表和链表。
链表顾名思义，像链条一样，将存储数据的结点一个一个串起来；每一个节点不仅存储数据，也存储指向下一个节点的指针。
不同于顺序表，其优点是，不需要一次开辟大量空间进行存储，根据需要随时动态申请内存。
缺点是，需要存储额外的指针。
而单链表，是每个节点只有一个指针。
单链表在内存中的分布可以抽象为下图：
在这里插入图片描述

链表插入时是否需要对传入的地址进行断言？

  1. 如果传入的是单链表头指针，是不需要断言的，因为即使是空链表，也可以插入呀~
  2. 但如果是顺序表的话，是需要对传入的指针进行断言的，因为如下图，传入的结构体指针是有数据的，数组指针、size、capacity，如果传入的指针为NULL，说明该顺序表不存在！
    在这里插入图片描述

顺序表的代码实现

//顺序表的定义
#include <assert.h>
typedef int SLDataType;
#define INIT_CAPACITY 4
typedef struct SeqList
{
	SLDataType* a;
	int size;
	int capacity;
}SL;

//顺序表的插入
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(pos >= 0 && pos <= ps->size);
	SLCheckCapacity(ps);
	int end = ps->size - 1;
	while (end >= pos)
		ps->a[end + 1] = ps->a[end--];
	ps->a[pos] = x;
	ps->size++;
}

1.2单链表代码实现

单链表的创销、增删改查函数代码实现如下

1.2.1 头文件

SList.h

//将所有可能用到的库文件中的头文件在.h文件中声明
#pragma once
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
typedef int SLTDataType;
typedef struct SLTNode
{
	SLTDataType data;
	struct SLTNode* next;
}SLTNode;//定义一个单链表

//单链表的打印、插入、删除函数声明
void SLTPrint(SLTNode* phead);//打印
SLTNode* BuySLTNode(SLTDataType x);//动态申请一个节点，用于插入
void SLTPushFront(SLTNode** pphead, SLTDataType x);//头插
void SLTPushBack(SLTNode** pphead, SLTDataType x);//尾插
void SLTPopFront(SLTNode** pphead);//头删
void SLTPopBack1(SLTNode** pphead);//尾删方式1
void SLTPopBack2(SLTNode** pphead);//尾删方式2
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
void SLTErase(SLTNode** pphead, SLTNode* pos);
void SLTEraseAfter(SLTNode* pos);
void SLTInsertAfter(SLTNode* pos, SLTDataType x);
void SLTDestroy1(SLTNode* phead);//销毁链表
void SLTDestroy2(SLTNode** phead);//传二级指针销毁链表

1.2.2 函数实现文件

SList.c

//单链表的打印、插入、删除函数实现
#include "SList.h"
void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

//封装的思想，头插、尾插都要申请节点，将其封装为函数，一方面调用方便；另一方面，方便维护，如果出了问题，在函数内部修复即可，如果没有封装，则每次使用这个功能的地方都要修复。
SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc failed");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

//插入没有必要对顺序表是否为空进行讨论，因为与非空操作一致
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
}

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = BuySLTNode(x);
	if (*pphead == NULL)
		*pphead = newnode;
	else
	{
		//找尾节点
		SLTNode* tail = *pphead;//命名的可读性
		while (tail->next != NULL)
			tail = tail->next;
		tail->next = newnode;
	}
}

//删除需要对链表为空的情况单独讨论，没有节点怎么删呀
//删除也要对只有一个节点情况进行讨论，因为第一个节点的内存被释放，与删除非第一个结点相比，要修改头指针，否则头指针成为野指针
//尾删方式1
void SLTPopBack1(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;
		SLTNode* prev = NULL;
		while (tail->next != NULL)
		{
			prev = tail;//记录尾节点的前一个节点的位置
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		
		//VS2022语法较为严格
		if (prev == NULL)
			return;
			
		prev->next = NULL;
	}
}

//尾删方式2
void SLTPopBack2(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		SLTNode* tail = *pphead;

		//VS2022语法较为严格
		if (tail == NULL || tail->next==NULL)
			return;

		//找到尾节点的前一个节点
		while (tail->next->next != NULL)
			tail = tail->next;
			
		free(tail->next);//释放尾节点所在内存
		tail->next = NULL;//将指向尾节点的指针置为空
	}
}

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

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

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

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

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

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

void SLTDestroy1(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur)
	{
		SLTNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
}

void SLTDestroy2(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* tmp = cur->next;
		free(cur);
		cur = tmp;
	}
	*pphead = NULL;
}

1.2.3 测试文件

Test.c

#include "SList.h"
//单链表的打印、插入、删除函数测试
void TestList1()
{
	SLTNode* plist = NULL;
	for (int i = 0; i < 10; i++)
		SLTPushFront(&plist, i);
	SLTPrint(plist);
	SLTPopBack1(&plist);
	SLTPrint(plist);
	SLTPopBack2(&plist);
	SLTPrint(plist);
}

//对头删函数进行测试
void TestList2()
{
	SLTNode* plist = NULL;
	for (int i = 0; i < 10; i++)
		SLTPushBack(&plist, i);
	SLTPopFront(&plist);
	SLTPrint(plist);
}
void TestList3()
{
	SLTNode* plist = NULL;
	for (int i = 0; i < 10; i++)
		SLTPushBack(&plist, i);
	for (int i = 0; i < 10; i++)
	{
		SLTPopFront(&plist);
		SLTPrint(plist);
	}
	//SLTPopFront(&plist);
}

//对尾删函数进行测试
void TestList4()
{
	SLTNode* plist = NULL;
	for (int i = 0; i < 10; i++)
		SLTPushBack(&plist, i);
	for (int i = 0; i < 10; i++)
	{
		SLTPopBack1(&plist);
		SLTPrint(plist);
	}
	//SLTPopBack1(&plist);
}

//对寻找、插入、删除、后插函数进行测试
void TestList5()
{
	SLTNode* plist = NULL;
	for (int i = 0; i < 10; i++)
		SLTPushBack(&plist, i+1);
	SLTPrint(plist);
	SLTNode* ret = SLTFind(plist, 3);
	ret->data *= 5;
	SLTPrint(plist);
	//SLTInsert(&plist, ret, 30);
	SLTErase(&plist, ret);
	SLTPrint(plist);
}
void TestList6()
{
	SLTNode* plist = NULL;
	for (int i = 0; i < 10; i++)
		SLTPushBack(&plist, i+1);
	SLTPrint(plist);
	SLTNode* ret = SLTFind(plist, 1);
	ret->data *= 5;
	SLTPrint(plist);
	//SLTInsert(&plist, ret, 30);
	//SLTErase(&plist, ret);
	//SLTInsertAfter(ret, 30);
	SLTEraseAfter(ret);
	ret = NULL;
	SLTPrint(plist);
}

//对链表销毁函数进行测试
void TestList7()
{
	SLTNode* plist = NULL;
	for (int i = 0; i < 10; i++)
		SLTPushBack(&plist, i + 1);
	SLTPrint(plist);
	/*SLTDestroy1(plist);
	plist = NULL;*/  //传头指针进行销毁，要将头指针置为NULL
	SLTDestroy2(&plist);
}
int main()
{
	TestList7();
	return 0;
}

1.2.4 野指针问题

对于销毁链表操作，有一个经典错误，就是野指针，其实其他场景下也会出现，代码示例如下。首先我们要清楚free(cur)到底做了什么，就是将cur指向的原本动态开辟的内存空间的使用权还给操作系统，cur的值可能变，也可能不变，但是即使不变，也不能通过cur再去使用其指向的那块空间了。通过调试我们可以看到，虽然free前后plist的值没有改变（下图红色框），但是free后，plist指向区域的data是随机值（下图橙色框），并且后续节点不能被访问（下图蓝色框），在free(plist)后打开plist的next域显示如下图黄色框。

在这里插入图片描述
举个例子，这就像住酒店，指针就像房卡，显示房间号，可以找到房间，也就是内存区域，free就像退房，退房后还有可能通过房卡找到房间吗？当然可以，可是没有使用权。用一个临时变量存储cur，并free(cur)，之后通过临时变量访问该地址，就像将房卡给别人，退房后还是不能使用该房间。

//错误范例1
void SLTDestroy2(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		free(cur);//此时cur已经是野指针了，下面不能在调用了
		cur = cur->next;
	}
	*pphead = NULL;
}
//错误范例2
void SLTDestroy2(SLTNode** pphead)
{
	assert(pphead);
	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* tmp = cur->next;
		free(tmp);//此时tmp已经是野指针了，下面不能在调用了
		cur = tmp->next;
	}
	*pphead = NULL;
}

总结

写代码时几个注意的点：

  1. 指针不一定要断言，只有一定不为空的指针才需要断言，具体情况具体分析；
  2. 要有封装的思想，多次使用的功能封装为函数；
  3. 在实际应用中，头插、尾插不一定要调用函数；
  4. 代码有不同的实现逻辑和方式，注意区分差别；
  5. 野指针问题经常出现，注意规避；
  6. 出现问题进行调试，观察出错步骤，进行修改。

上面的代码即思想在做链表相关的题时很有用，希望大家可以动手写一写~

苏宸啊
关注
专栏目录
单链表遍历_单链表及其遍历实现的基本操作
cumt951045的博客
08-03 1万+
单链表遍历 单链表 (Single linked list) Single linked list contains a number of nodes where each node has a data field and a pointer to next node. The link of the last node is to NULL, indicates end of list. ...
C语言单链表代码
weixin_42104550的博客
08-26 2924
下面的内容对初学者来说很抽象，建议多画图理解，或者去看熟悉我的C语言内存结构以及指针研究的文章再来理解链表。 顺序表的缺点可以用链表来解决，链表也分为单链表和双链表。这一文只展示单链表的代码。为什么单链表的访问效率极高，而且不会因为表的长度而影响的。因为链表在每一个数据前面都有一个地址头，也就是说链表的每个数据其实是有头有尾的，头是一个指向尾的地址，尾部才是真正的用户存储的数据。 每个数据是这样存储的，next是地址指针 data才是数据。每个数据都是独立的一个节点，只是这些块节点有next指针把它们串
单链表及其Java代码实现
Beau Wang
12-04 783
众所周知，数组和链表都有内存寻址的功能。而数组元素的内存地址是连续的，在寻址的时候很容易就可以找到下一个节点的值。 而链表中元素的地址不是连续的，那我们应该怎么去寻址呢？ 假设现在计算机中有三个节点：5，6，2，这三个节点内存地址是不连续的。我们想要通过5找到6，通过6找到2，就需要在存储数据的同时将下一个节点的地址一并存进来，这样的话，我们就可以实现寻址的功能。这其实就是一个简单的链表（如下图）。 我们现在知道了链表的概念，那我们如何用java写一个单链表呢？ 因为java没有自带链表..
单链表的定义及其代码实现
qq_45965736的博客
09-09 1097
对不带头结点与带头结点的链表的比较
单链表及其实现
White__River的博客
03-23 962
单链表及其实现 1. 单链表的概念 用链式储存结果存储数据的线性表，是为链表 链式存储，意思就是逻辑上相邻的数据，物理位置不一定相邻 因此需要指针 可以给每个元素附加上一个指针，这个指针的作用，就是作为下一个元素的地址，指向下一个元素 所以链表中的每个节点，包含两个域：数据域和指针域 数据域存储数据元素，指针域存储下一个节点的地址 注意！！！指针域存储的地址，是下一个节点的地址，而并非下一个数据元素的地址，you feel me？ 链表的第一种，称之为单向链表，简称单链表，就是一个个地指向下一个 首先定义节
C语言实现单链表及其打印
mastershooter的博客
09-24 1018
（比如第一个空间地址是A，第二个是B，第三个是C，第四个是D，那么第一个空间的指针是第二个空间的地址，第二个空间的指针是第三个空间的地址，以此类推）单链表与顺序表的不同之处就是：单链表并不会和顺序表一样有对应的下标，单链表的每个空间的地址是不连续的，但是每个空间都会有一个指针指向下一个空间，所以从空间来说是连续的。由上图可看见，n1->next是存有n2的地址，n2->next是存有n3的地址，而最后一个n4->next是指向空，此时说明我们的单链表创建成功了。当然是赋NULL，空指针。
Java实现单链表及其基本操作
qq_58284486的博客
03-14 8400
目录 什么是单链表？ 带头结点的单链表 不带头结点的单链表 模拟实现不带头结点的单链表 定义结点类 初始化 头插法创建单链表 尾插法创建单链表 打印单链表 单链表的查找 获取单链表的长度 按位置寻找前驱结点 单链表的插入 修改指定位置的值 按值寻找前驱结点 删除第一次出现的key值 删除所有的key值 清空单链表 完整代码 什么是单链表？ 单链表是一种链式存取的数据结构，用一组任意的存储单元存放线性表中的数据元素。链表中的数据是以结点表示...
单链表介绍及其实现
夜飘凌的博客
04-09 273
链表 文章目录链表链表的专业术语：实现 链表的专业术语： 首节点：存放第一个有效数据的结点； 尾结点：存放最后一个有效数据的结点；尾指针指向； 头结点：头结点的数据类型和首结点的类型一模一样； 头结点是首节点前面的那个结点； 头结点并不存放有效数据； 设置头结点的目的是为了方便存储数据； 头指针：存放头结点地址的指针变量，指向头结点； 单链表的插入实现逻辑： 链表插入的核心语句： ...
[Java]实现单链表及其基本操作
sjhdaj的博客
03-20 815
带头结点的单链表第一个结点作为头结点，并在其下半部分存放第一个结点的地址，之后的每个结点都会在上半部分存放元素值，在下半部分存放下一个结点的地址。如果我们要在一个单链表表头插入一个结点，我们需要先让此结点成为一个新的头结点，并让该新头结点的地址域存放原来第一个结点的地址。如果我们要删除的结点是第一个结点，则直接使头结点连接第二个结点即可，如果是删除其他的结点，则需要找到该结点的前驱结点在进行删除。如果我们要在单链表的尾部插入一个元素，只要将原来单链表尾部的元素地址域指向下一个结点的地址即可。
cpp代码-单链表的基本实现
07-14
本文将详细解析标题“cpp代码-单链表的基本实现”所涵盖的知识点，并结合描述和提供的文件名来深入探讨。 单链表是一种线性数据结构，其中每个元素（称为节点）包含两个部分：数据域和指针域。数据域存储实际的数据...
单链表及其应用
01-07
### 单链表及其应用 #### 实验背景与目的 单链表作为一种基本的数据结构，在计算机科学领域中占据着极其重要的地位。它不仅能够高效地处理动态数据集合，还为解决许多实际问题提供了灵活的方法。本次实验旨在让...
单链表的逆置的四种方法及部分代码实现
04-26
### 单链表逆置的四种方法及其代码实现 #### 一、引言 单链表作为数据结构中的一种基本形式，在计算机科学中扮演着重要角色。链表的逆置是指将链表中的元素顺序完全颠倒过来。本文将详细介绍单链表逆置的四种常用...
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 337
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】【顺序表算法】 删除特定范围内的元素
最新发布
Indigo____的博客
10-04 232
题目：从顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。
【数据结构初阶】排序算法(中)快速排序专题
fhvyxyci的博客
09-28 1275
1. 快排主框架 2. 快排的不同实现 2. 1 hoare版本 2. 2 挖坑法 2. 3 lomuto前后指针法 2. 4 快排的非递归版本 3. 快排优化 3. 1 快排性能的关键点分析: 3. 1 三路划分 3. 2 introsort自省排序
数据结构-3.8.栈在括号匹配中的应用
ADCvbV的博客
10-01 515
把左括号依次压入栈中，越往后压入栈的左括号越先被匹配即被弹出栈->先进后出，后进先出当遇到左括号就压入栈中，当遇到右括号就把栈顶的左括号弹出，检查该右括号和左括号是否匹配当遇到一个不匹配的就停止压入栈，因为之后的括号必定都不匹配。其中Y代表Yes，N代表No1.对于bracketCheck函数，形参str[]是传入的一个字符串，length是该字符串的长度；字符topElem代表栈顶元素；return StackEmpty(S)如果是return false说明栈不为空，则左括号单身；创建栈顶元素topEl
（JAVA）队列 和 符号表 两种数据结构的实现
ZunXin_2580的博客
09-27 671
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
运用循环单链表实现约瑟夫问题c语言代码
09-27
约瑟夫环是一个经典的算法问题，通常用于演示递归和模运算的概念。在循环单链表中实现约瑟夫问题，首先需要创建一个节点结构和一个头指针，然后模拟人们从列表中按顺序移除并跳过指定步骤的过程。 以下是一个简单的C语言代码示例： ```c #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct Node* next; } Node; Node* createNode(int value) { Node* newNode = (Node*)malloc(sizeof(Node)); newNode->data = value; newNode->next = NULL; return newNode; } void josephusProblem(Node* head, int steps) { if (head == NULL || steps <= 0) { printf("Invalid input.\n"); return; } Node* victim = head; for (int i = 1; i <= steps - 1; i++) { victim = victim->next; } while (victim != NULL) { Node* temp = victim->next; free(victim); victim = temp; if (victim == NULL) { victim = head; while (victim->next != head) { victim = victim->next; } } else { for (int i = 1; i < steps; i++) { victim = victim->next; } } } } // 添加节点到链表 void appendToList(Node** head, int value) { Node* newNode = createNode(value); if (*head == NULL) { *head = newNode; } else { Node* current = *head; while (current->next != NULL) { current = current->next; } current->next = newNode; } } int main() { Node* head = NULL; int n, steps; printf("Enter the number of people: "); scanf("%d", &n); for (int i = 1; i <= n; i++) { appendToList(&head, i); } printf("Enter the step count: "); scanf("%d", &steps); josephusProblem(head, steps); printf("The last person standing is at position %d\n", head->data); return 0; } ``` 在这个代码里，用户先输入人数和步骤数，然后程序会创建一个循环链表，并应用约瑟夫环算法。`josephusProblem`函数负责执行约瑟夫环的规则，最后输出存活的人及其位置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值