数据结构：单链表的实现(C语言)

于 2023-07-31 19:24:20 发布
阅读量1.4k 收藏 41
点赞数 51
分类专栏： 数据结构 文章标签： 数据结构 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li209779/article/details/131991380
版权

在这里插入图片描述

个人主页 ： 水月梦镜花
个人专栏 ： 《C语言》 《数据结构》

文章目录

前言

本博客将要实现的无头单向不循环链表。

一、单链表实现思路和图解

1.节点的定义(SListNode)

我们将节点定义为如下结构：
在这里插入图片描述
其成员变量有data，next。

将int重命名为STLDataType，方便我们以后修改数据域的内容。

//无头单向不循环链表
typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SListNode;

2.申请一个节点(BuySListNode)

动态申明一个空间，来放置数据。如下：
在这里插入图片描述
将data的内容置成形参x，next置NULL。

//申请一个节点
SListNode* BuySListNode(SLTDataType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	retur

3.单链表打印(SListPrint)

循环遍历链表，直到尾节点。创建一个结构体指针变量cur，循环cur = cur->next，并打印cur->data的内容，直到cur == NULL。
在这里插入图片描述

//单链表打印
void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;

	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

4.单链表尾插(SListPushBack)

  • 如果链表不为NULL(链表中有元素)，要先遍历链表找到尾节点，在让尾节点指向新节点，完成尾插。
  • 如果链表为NULL(链表中没有元素)，此时应该直接让新节点等于头结点，完成尾插。(本链表是无哨兵位的)
  • 如果传入的头结点无效，直接判错。

在这里插入图片描述

在这里插入图片描述
当链表为NULL，我们就要修改头结点本身的内容，所以我们需要头结点的指针，而本文中头结点本身就是结构体指针，所以尾插函数参数我们需要二级指针。

//单链表尾插
void SListPushBack(SListNode** pplist, SLTDataType x)
{
	assert(pplist);

	SListNode* newnode =  BuySListNode(x);
	if (*pplist != NULL)
	{
		SListNode* cur = *pplist;
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
	else
	{
		*pplist = newnode;
	}
}

5.单链表的头插(SListPushFront)

对于头插而言，链表是否有元素并不重要，我们只需要让新节点的指向头结点，并将头结点等于新节点。

在这里插入图片描述
因为头插链表，一定会改变头结点的内容，所以我们头插函数的形参也是二级指针。

//单链表的头插
void SListPushFront(SListNode** pplist, SLTDataType x)
{
	assert(pplist);

	SListNode* newnode = BuySListNode(x);
	
	newnode->next = *pplist;
	*pplist = newnode;
}

6.单链表的尾删(SListPopBack)

  • 如果链表元素有两个及两以上，我们需要两个指针变量prev，next来找尾节点，循环prev = cur，cur = cur->next，使next指向尾节点，prev指向尾节点的前一个，free尾节点，prev指向的节点指向NULL。
  • 如果链表元素只有一个，直接free头结点，使头结点置NULL。
  • 如果链表没有元素，直接判错。

在这里插入图片描述

在这里插入图片描述
当链表元素只有一个时，此时尾删链表，要修改头结点的内容，尾删函数的形参需要二级指针。

//单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);
	//链表为NULL
	assert(*pplist);

	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SListNode* cur = *pplist;
		SListNode* prev = NULL;

		while (cur->next != NULL)
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = NULL;
		free(cur);
	}
}

7.单链表头删(SListPopFront)

我们需要一个结构体指针变量next，来保存头结点的下一个节点，然后free头结点，使头结点 = 指针变量next。

  • 如果链表没有元素，直接判错。

在这里插入图片描述

//单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);
	assert(*pplist);

	SListNode* next = (*pplist)->next;
	free(*pplist);
	*pplist = next;
}

8.单链表的查找(SListFind)

我们需要一个结构体指针变量cur，来遍历链表比较cur->data == x，如果相等，放回此时cur的内容(该节点的地址)。如果遍历完链表，并没有相等元素，放回NULL。

//单链表的查找
SListNode* SListFind(SListNode* plist, SLTDataType x)
{
	SListNode* cur = plist;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}

9.单链表在pos位置之后插入x(SListInsertAfter)

我们让newnode指向pos下一个的节点，pos指向newnode。

  • 如果我们先让pos指向newnode，newnode在指向pos的下一个节点，就会造成newnode指向自己，导致链表成环。
  • 该函数不会影响头结点的内容，所以函数的形参不用二级指针。

在这里插入图片描述


//单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDataType x)
{
	assert(pos);

	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

10.单链表删除在pos位置之后的值(SListEraseAfter)

我们需要一个结构体指针变量next，记录pos下一个节点的地址，然后是pos指向next的下一个节点，接着free(next)。

  • 如果链表只有一个元素，我们不能调用该函数，否则会导致NULL指针的解引用。
  • 该函数不会改变头结点的内容，所以形参我们不用二级指针。

在这里插入图片描述


//单链表删除在pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
	assert(pos && pos->next);

	SListNode* next = pos->next;
	pos->next = next->next;
	free(next);
}

11.单链表的销毁(SListDestroy)

我们需要两个结构体指针prev，cur。先让prev = cur ，cur再指向下一个节点，free(prev)，重复上述操作，直到cur指向NULL。

在这里插入图片描述
需要我们在函数调用完后，自己对头结点置NULL。

//单链表的销毁
void SListDestroy(SListNode* plist)
{
	assert(plist);

	SListNode* cur = plist;
	while (cur != NULL)
	{
		SListNode* prev = cur;
		cur = cur->next;
		free(prev);
	}
}

二、代码实现

//slist.h  文件


#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

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

//无头单向不循环链表
typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SListNode;


//申请一个节点
SListNode* BuySListNode(SLTDataType x);

//单链表打印
void SListPrint(SListNode* plist);

//单链表尾插
void SListPushBack(SListNode** pplist, SLTDataType x);

//单链表的头插
void SListPushFront(SListNode** pplist, SLTDataType x);

//单链表的尾删
void SListPopBack(SListNode** pplist);

//单链表头删
void SListPopFront(SListNode** pplist);

//单链表的查找
SListNode* SListFind(SListNode* plist, SLTDataType x);

//单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDataType x);

//单链表删除在pos位置之后的值
void SListEraseAfter(SListNode* pos);

//单链表的销毁
void SListDestroy(SListNode* plist);

//slist.c    文件


#include "slist.h"

//申请一个节点
SListNode* BuySListNode(SLTDataType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;
}


//单链表打印
void SListPrint(SListNode* plist)
{
	SListNode* cur = plist;

	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}


//单链表尾插
void SListPushBack(SListNode** pplist, SLTDataType x)
{
	assert(pplist);

	SListNode* newnode =  BuySListNode(x);
	if (*pplist != NULL)
	{
		SListNode* cur = *pplist;
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		cur->next = newnode;
	}
	else
	{
		*pplist = newnode;
	}
}


//单链表的头插
void SListPushFront(SListNode** pplist, SLTDataType x)
{
	assert(pplist);

	SListNode* newnode = BuySListNode(x);
	
	newnode->next = *pplist;
	*pplist = newnode;
}

//单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);
	//链表为NULL
	assert(*pplist);

	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
		SListNode* cur = *pplist;
		SListNode* prev = NULL;

		while (cur->next != NULL)
		{
			prev = cur;
			cur = cur->next;
		}
		prev->next = NULL;
		free(cur);
	}
}


//单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);
	assert(*pplist);

	SListNode* next = (*pplist)->next;
	free(*pplist);
	*pplist = next;
}


//单链表的查找
SListNode* SListFind(SListNode* plist, SLTDataType x)
{
	SListNode* cur = plist;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
}

//单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDataType x)
{
	assert(pos);

	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}


//单链表删除在pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
	assert(pos && pos->next);

	SListNode* next = pos->next;
	pos->next = next->next;
	free(next);
}


//单链表的销毁
void SListDestroy(SListNode* plist)
{
	assert(plist);

	SListNode* cur = plist;
	while (cur != NULL)
	{
		SListNode* prev = cur;
		cur = cur->next;
		free(prev);
	}
}

总结

以上就是我对于无头单向不循环链表的实现！！！

在这里插入图片描述

水月梦镜花
关注
专栏目录
【数据结构】实现单链表
gwPersevere的博客
05-02 729
前言 上一篇博客写了顺序表，我们都知道顺序表有两个优点1.物理空间连续，2.下标随机访问，也是因为它的两个优点让它产生了一下缺点：1.空间不够时需要扩容，而扩容呢有存在性能消耗；2.在头部插入数据、在某个位置插入数据、在某个位置删除数据它需要挪动数据，这就存在效率低的问题。解决这来两个问题我们可以用链表。 链表是在逻辑上连续在物理上又不连续的一种结构，它的逻辑上连续是通过指针来完成的。 链表又可分为：单向或者双向链表、带头或者不带头链表、循环或者非循环链表，这几种组合起来有8种结构： 常用的有：
数据结构：单链表（C语言）
m0_49070560的博客
09-26 1283
一、链式存储结构——链表的几个概念 链表与线性表的区别在于，链表分为数据域和指针域两个部分，每个存储单元可以是连续的，也可以是不连续的， 1.头指针：链表中第一个结点的存储位置叫做头指针 2.头结点：在单链衰的第一个结点前附设一个个结点，称为头结点。 特点： （1）用一组任意的存储单元存储线性表的数据元素 （2）这组存储单元可以是连续的，也可以是不连续的 （3）每个数据元素除了存储数据外，还要存储前驱、后继元素的地址 线性链表的最后一个结点指针为空，通常用 NULL或 ^ 符号表示 ...
数据结构（初阶）—— C语言实现单链表
M的博客
04-02 1791
数据结构（初阶）——C语言实现单链表
【数据结构】单链表的实现
adcxhw的博客
04-06 1063
快来看呀，小陳同学开始啃数据结构咯。
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
最新发布
10-19
在C语言中实现数据结构能够帮助我们深入理解底层工作原理，并为编写高性能的程序打下坚实基础。以下是关于标题和描述中提及的数据结构的详细讲解： 1. **单链表**： 单链表是一种线性数据结构，每个元素（节点）...
数据结构-C语言版：单链表例题.ppt
06-06
数据结构-C语言版：单链表例题.ppt
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
【数据结构】单链表实现
qq_55829345的博客
01-16 520
单链表的实现，几个牛客网和力扣的链表题目。
数据结构：单链表的实现
CSU_hhxyliang的博客
08-16 230
数据结构：单链表的实现 #include <iostream> using namespace std; typedef int ElemType; typedef void Status; /* 创建一个新节点 * data表示数据域、*next表示指针域 * 对指针域的定义不能用新的结构体名 */ typedef struct Node { ElemType data; ...
数据结构---单链表的实现
weixin_71594206的博客
04-25 367
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
数据结构—单链表的实现
宇哲
06-04 3631
关于单链表，是最熟悉不过的一种数据结构了。今天，花费了很长的时间写出了单链表，和大家分享一下，有问题大家可以提出来！！！linklist.h#define _CRT_SECURE_NO_WARNINGS 1#ifndef __LINKLIST_H__ #define __LINKLIST_H__ #include<stdio.h> #include<stdlib.h> #include<assert
数据结构--单链表的实现
syt160623的博客
08-10 249
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include "LinkList.h" /* run this program using the console pauser or add your own getch, system("pause") or input loop */ struct value { LinkListN...
数据结构单链表简单实现
dongfengxueli的博客
07-30 263
单链表节点定义： typedef struct LNode{ ElemType data; //数据域 struct LNode *next; //指针域 }Lnode,*LinkList; 1 头插法建立单链表 采用头插法建立单链表，读入数据顺序与生成链表中的元素顺序是相反的，每个节点的插入时间是o（1），总的时间复杂度是o（...
数据结构之单链表实现
一个人的学习和碎碎念
05-27 249
用两个月的时间好好把数据结构复习一遍，都算不上复习了，最后的图的方面完全是新学，希望能坚持下去。一、单链表    链表相比较于数组更为灵活，存储方式是链式的，插入删除操作优于数组，但是查询操作优于数组。还是不多介绍了直接上代码吧。（代码参考数据结构与算法分析-c语言版本）//头文件 #ifndef LIST_H #define LIST_H struct Node; tydedef struct ...
数据结构：单链表与结点实现解析
"数据结构第一二章课件涵盖了单链表、结点的C语言描述以及单链表操作的实现等内容，讲解了线性表的链式表示和存储结构。" 在数据结构中，线性表是一种基本的数据组织形式，由有限个相同类型元素构成的有序序列。在...
评论 48
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

水月梦镜花

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

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

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

打赏作者

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

抵扣说明：

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

余额充值