数据结构之单链表

最新推荐文章于 2022-09-06 19:18:22 发布
最新推荐文章于 2022-09-06 19:18:22 发布
阅读量788 收藏 9
点赞数 21
分类专栏： 数据结构 文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45806959/article/details/119955158
版权

目录

简介

线性表的顺序存储结构有一个缺点就是插入和删除时需要移动大量元素，这会耗费许多时间。能不能想办法解决呢？
干脆所有的元素都不要考虑相邻位置了，哪有空位就到哪里，让每一个元素都知道它下一个元素的位置在哪里。
线性表链式存储结构： 用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的，也可以是不连续的)。
链表是由一个个结点链结成的。
结点包括数据域和指针域两部分，数据域用来存储数据元素的信息，指针域用来存储下一个结点的地址。
在这里插入图片描述接下来实现一个无头单向非循环链表。

单链表结构的定义

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;		//数据
	struct SListNode* next;		//指向下一个结点的指针
}SLTNode;

单链表打印

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

在这里插入图片描述
将指向链表的指针plist做参数传给函数，遍历一遍链表并输出每个结点数据域的内容。

动态申请一个结点

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

用malloc动态开辟一个结点，如果node为NULL说明开辟失败，退出程序。否则将结点node的数据域赋值为x，指针域赋值为NULL。

单链表尾插

如果单链表为空，开辟一个新结点用指针指向它即可；如果链表不为空，需要开辟一个新结点，然后找到链表的最后一个结点，让最后一个结点的指针域存放新结点的地址。
有一个链表，为链表尾插一个新结点：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);		//plist地址一定不为NULL，进行断言
	if (*pphead == NULL)	//链表为空
	{
		SLTNode* newnode = BuySListNode(x);
		*pphead = newnode;
	}
	else           //链表不为空
	{		
		SLTNode* tail = *pphead;
		while (tail->next)		//找到最后一个结点
			tail = tail->next;
		SLTNode* newnode = BuySListNode(x);
		tail->next = newnode;
	}
}

在这里插入图片描述
为指针不好的同学解释下参数，plist为指向结构体的指针，指向链表的头结点，打印函数的形参phead为plist的一个临时拷贝，作用和plist是一样的，这里的尾插函数pphead为指针plist的地址，是一个二级指针。因为当链表为空时，会改变指针的指向，所以参数用二级指针。
在这里插入图片描述

单链表尾删

如果链表只有一个结点，把这个结点free掉即可。如果链表有多个结点，找到链表的尾结点和尾结点的前一个结点，让尾结点的前一个结点的指针域指向NULL，free掉尾结点。
在这里插入图片描述

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);		//断言pphead
	assert(*pphead);	//当链表为空时说明没有结点，没法进行删除操作，所以*pphead不能为NULL
	if ((*pphead)->next == NULL)	//只有一个结点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else                //多个结点
	{
		SLTNode* tail = *pphead;	//tail表示为节点
		SLTNode* prev = NULL;		//prev表示尾结点的前一个结点
		while (tail->next)		//找到尾结点和尾结点的前一个结点
		{
			prev = tail;
			tail = tail->next;
		}
		prev->next = NULL;
		free(tail);
		tail = NULL;
	}
}

单链表头插

申请一个新结点，让新结点的指针域存放头结点的地址，原来指向头结点的指针plist指向新结点，新结点就变成了新的头结点。
在这里插入图片描述

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

单链表头删

用一个指针指向头结点的下一个结点，把头结点的空间释放掉，指向头结点的指针指向头结点的下一个结点。头结点的下一个结点就变成了新的头结点。同时要考虑链表为空时不能删除，进行相应的断言。
在这里插入图片描述

void SListPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* next = (*pphead)->next;	//指针next记录头结点的下一个结点
	free(*pphead);
	*pphead = next;
}

求单链表长度

int SListSize(SLTNode* phead)
{
	int size = 0;
	SLTNode* cur = phead;
	while (cur)
	{
		++size;
		cur = cur->next;
	}
	return size;
}

单链表查找

遍历一遍单链表，如果某一结点数据域内容与要查找内容相同，返回该结点。遍历完没有找到，返回NULL。

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

单链表在pos位置插入

在pos位置插入，如果pos这个位置是头结点，和头插的逻辑是一样的，可以调用之前写过的头插函数。
如果这个位置是除头结点外的任意一个结点，我们需要申请一个新结点，并且记录pos结点的前一个结点，让新结点的指针域存放pos的地址，让pos前一个结点的指针域存放新结点的地址，把它们链结起来。
在这里插入图片描述

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);		//指向头结点指针的地址不能为NULL，进行断言
	assert(pos);		//插入位置pos不能为NULL进行断言
	if (pos == *pphead)		//要插入的位置pos和头结点是一个位置
	{
		SListPushFront(pphead, x);
	}
	else                //pos不是头结点
	{
		SLTNode* prev = *pphead;    //prev用来找到pos位置的前一个结点
		while (prev->next != pos)
			prev = prev->next;
		SLTNode* newnode = BuySListNode(x);		//申请一个新结点
		newnode->next = pos;		//把新结点链结
		prev->next = newnode;
	}
}

单链表在pos后面位置插入

申请一个新结点，让新结点的指针域存放pos结点下一个结点的地址，pos结点的指针域存放新结点的地址。
在这里插入图片描述

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

单链表删除pos位置

如果pos位置是头结点，删除逻辑和头删相同，调用头删函数即可。
如果是除头结点外的其它结点，找到pos的前一个结点，让这个结点的指针域指向pos的下一个结点。把pos结点空间释放。
在这里插入图片描述

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);	//pphead不能为空，链表不能为空进行断言
	assert(pos);			//pos不能为空
	if (pos == *pphead)		//要删除的位置pos是头结点
	{
		SListPopFront(pphead);
	}
	else                    //不是头结点
	{
		SLTNode* prev = *pphead;	//prev指针用来找到pos结点的前一个结点
		while (prev->next != pos)
			prev = prev->next;
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

单链表删除pos的下一个结点

记录下pos的下一个结点，pos结点指针域指向pos下一个结点指针域指向的结点，释放掉pos的下一个结点。
在这里插入图片描述

void SListEraseAfter(SLTNode* pos)
{
	//pos不能为空，不能为尾结点，因为尾结点的下一个是NULL，什么也删除不了
	assert(pos && pos->next);	
	SLTNode* next = pos->next;		//next指针指向pos下一个结点
	pos->next = next->next;
	free(next);
	next = NULL;
}

判断单链表是否为空

bool SListEmpty(SLTNode* phead)
{
	return phead == NULL;
}

头文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;		//数据
	struct SListNode* next;		//指向下一个结点的指针
}SLTNode;

//打印
void SListPrint(SLTNode* phead);
//新节点
SLTNode* BuySListNode(SLTDataType x);
//尾插
void SListPushBack(SLTNode** pphead, SLTDataType x);
//尾删
void SListPopBack(SLTNode** pphead);
//头插
void SListPushFront(SLTNode** pphead, SLTDataType x);
//头删
void SListPopFront(SLTNode** pphead);
//长度
int SListSize(SLTNode* phead);
//查找
SLTNode* SListFind(SLTNode* phead, SLTDataType x);
//在pos位置插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//pos位置后面插入
void SListInsertAfter(SLTNode* pos, SLTDataType x);
//删除pos位置
void SListErase(SLTNode** pphead, SLTNode* pos);
//删除pos后面位置
void SListEraseAfter(SLTNode* pos);
//判空
bool SListEmpty(SLTNode* phead);

源文件

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"

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

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

void SListPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);		//plist地址一定不为NULL，进行断言
	if (*pphead == NULL)	//链表为空
	{
		SLTNode* newnode = BuySListNode(x);
		*pphead = newnode;
	}
	else           //链表不为空
	{		
		SLTNode* tail = *pphead;
		while (tail->next)
			tail = tail->next;
		SLTNode* newnode = BuySListNode(x);
		tail->next = newnode;
	}
}

void SListPopBack(SLTNode** pphead)
{
	assert(pphead);		//断言pphead
	assert(*pphead);	//当链表为空时说明没有结点，没法进行删除操作，所以*pphead不能为NULL
	if ((*pphead)->next == NULL)	//只有一个结点
	{
		free(*pphead);
		*pphead = NULL;
	}
	else                //多个结点
	{
		SLTNode* tail = *pphead;	//tail表示为节点
		SLTNode* prev = NULL;		//prev表示尾结点的前一个结点
		while (tail->next)		//找到尾结点和尾结点的前一个结点
		{
			prev = tail;
			tail = tail->next;
		}
		prev->next = NULL;
		free(tail);
		tail = NULL;
	}
}

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

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

int SListSize(SLTNode* phead)
{
	int size = 0;
	SLTNode* cur = phead;
	while (cur)
	{
		++size;
		cur = cur->next;
	}
	return size;
}

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

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);		//指向头结点指针的地址不能为NULL，进行断言
	assert(pos);		//插入位置pos不能为NULL进行断言
	if (pos == *pphead)		//要插入的位置pos和头结点是一个位置
	{
		SListPushFront(pphead, x);
	}
	else                //pos不是头结点
	{
		SLTNode* prev = *pphead;    //prev用来找到pos位置的前一个结点
		while (prev->next != pos)
			prev = prev->next;
		SLTNode* newnode = BuySListNode(x);		//申请一个新结点
		newnode->next = pos;		//把新结点链结
		prev->next = newnode;
	}
}

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

void SListErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);	//pphead不能为空，链表不能为空进行断言
	assert(pos);			//pos不能为空
	if (pos == *pphead)		//要删除的位置pos是头结点
	{
		SListPopFront(pphead);
	}
	else                    //不是头结点
	{
		SLTNode* prev = *pphead;	//prev指针用来找到pos结点的前一个结点
		while (prev->next != pos)
			prev = prev->next;
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

void SListEraseAfter(SLTNode* pos)
{
	//pos不能为空，不能为尾结点，因为尾结点的下一个是NULL，什么也删除不了
	assert(pos && pos->next);	
	SLTNode* next = pos->next;		//next指针指向pos下一个结点
	pos->next = next->next;
	free(next);
	next = NULL;
}

bool SListEmpty(SLTNode* phead)
{
	return phead == NULL;
}
北川_
关注
  • 21
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 21
    评论
专栏目录
数据结构之单链表操作合集.zip
06-16
这个“数据结构之单链表操作合集.zip”文件显然是针对大学生学习数据结构而准备的资源，包含了丰富的学习材料。下面将详细讨论单链表的相关知识点。 单链表是一种线性数据结构，由一系列节点（也称为元素或记录）...
【数据结构】单链表--List
Z1tai的博客
05-12 1万+
概念：链表是一种物理存储结构上非连续非顺序的存储结构，但链表在逻辑上是连续的，顺序的，而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。
[数据结构]链表之单链表（详解）
m0_63123468的博客
03-28 1万+
[数据结构]链表之单链表的详细解析
【数据结构】——单链表超详细介绍（独家介绍，小白必看！！！）
热门推荐
yakiyakiya的博客
09-06 2万+
今天又是认真更新的一天耶！！一万字的文章，带你吃透单链表！文章内含链表的构建、链表构建时的易错点和注意事项以及链表与顺序表的区别，详细讲解到小白都能学会。
数据结构——单链表
cdz2470的博客
04-10 2040
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。单链表中每个结点的结构如下：数据域保存了存储在该地址的数据，但指针域的指针却存放的不是该地址，而是下一个元素的地址。因此，整个单链表的结构如下：最后一个元素的指针域的指针设为nullptr，表示单链表到此结束。一般情况下，为了操作统一，设置了一个在所有数据结点之前的一个结点，称为头结点。可以利用该结点的数据部分存储单链表的个数。而指向头节点的指针称为头指针。
单链表（数据结构）
小的博客
08-02 8530
链表链表概念空表的表示单链表的实现单链表的建立1.头插法2.尾插法 链表概念 线性表的链式存储结构：线性表中数据元素（结点）在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理位置上不一定相邻。 1. 相关术语 结点：数据元素的存储映像。由数据域和指针域两部分组成。 数据域：存放数据 指针域：存放指向下个结点的地址 链表：n个结点由指针链组成一个链表 2.头指针、头结点、首元结点 头指针:是指向链表中第一个结点的指针 头结点：是在链表的首元结点之前附设的一个结点 首元节点：是指链表中存储第一个数
单链表-C++数据结构之单链表实现.zip
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
使用C++实现链表数据结构之单链表.zip
03-13
链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在处理动态数据集合时。本主题将深入探讨如何使用C++语言实现单链表。单链表是链表的一种基本形式，每个节点包含数据和指向下一个节点的指针。 ...
Python数据结构之单链表详解
09-21
主要为大家详细介绍了Python数据结构之单链表的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
基于JAVA的数据结构之单链表操作合
最新发布
03-25
单链表是一种基础且重要的数据结构，它在计算机科学中被广泛使用，特别是在编程语言如Java中。单链表由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。这种数据结构允许动态地添加、删除和...
C语言 数据结构之单链表基本操作
10-05
单链表的各种操作，适合于初学，也适合于复习 单链表操作介绍 1. 创建头节点 2. 创建有数据节点 3. 判断链表是否为空 4. 遍历链表(有头节点链表) 5. 遍历链表(无头节点链表) 6. 头插、头删、尾插、尾删 7. 按照顺序...
python算法与数据结构之单链表的实现代码
09-19
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。这篇文章主要介绍了python算法与数据结构之单链表的实现代码,需要的朋友可以参考下
C#数据结构之单链表(LinkList)实例详解
09-03
单链表（LinkList）是计算机科学中一种基础的数据结构，尤其在编程语言如C#中，它提供了灵活且高效的方式来存储和操作序列数据。单链表的主要特点是每个节点包含两个部分：数据部分（data）和一个指向下一个节点的...
单链表详解
weixin_63246064的博客
01-31 3182
一、什么是链表 数据结构就是用某种结构去储存数据： 1、物理结构(数据在内存中的存储) 2、逻辑结构(由人为想象出来的) 顺序表就是逻辑和物理都连续的一种线性表。 链表就是逻辑连续，物理不一定连续的线性表。如下图，逻辑上是利用指针将其串联起来的，物理上却是杂乱的。 ...
数据结构 —— 单链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-06 2875
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
python3怎么创建一个链表_「C语言」链表的操作——增删改查——让你一次全弄懂
weixin_39825722的博客
11-24 214
1.什么是链表1.1什么是链表链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。----百度百科上面关于链表的定义来源于百度百科，光看定义我想大部分人跟我初次看的时候一样，这讲的是个啥玩...
【 数据结构 】单链表的实现 - 详解（C语言版）
上上谦. 的博客
03-22 1万+
前言 简单用C语言来描述数据结构中的单链表，本文实现的只是简单的无头单链表，包括单链表的增加数据，删除数据，查找指定数据，修改指定数据，也就是简单的增删查改等操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北川_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值