单链表的简单实现

已于 2022-04-10 16:37:59 修改
阅读量1k 收藏 1
点赞数 4
分类专栏： 数据结构 文章标签： c语言 数据结构 链表
于 2022-04-10 16:37:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57249790/article/details/124080410
版权

 

目录

1、链表与顺序表的差异

2、定义一个SListNode结构体

3、动态申请一个节点

4、单链表的打印

5、单链表的尾插

6、 单链表的头插

7、单链表的尾删

8、 单链表的头删

9、单链表的查找

10、在pos之后插入数据

11、在pos之后删除数据

12、单链表的销毁

13、完整代码

14、结尾

1、链表与顺序表的差异

上一篇我们简单实现了顺序表，那么这一篇来简单实现一下单链表。

顺序表缺陷：

1. 中间/头部的插入删除，时间复杂度为O(N)
2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们
再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

因此我们引入了链表，链表：概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

由此可见，链表在结构上给我们提供了顺序表所不能提供的便利。

2、定义一个SListNode结构体

typedef int SLTDateType;

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

不难发现我们在SListNode 中定义了一个 struct SListNode * 的next指针变量 用来指向后面数据的地址。

3、动态申请一个节点

//动态申请一个节点
SListNode* BuyListNode(SLTDateType x)
{
	SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));
	if (newNode == NULL)
		return NULL;
	newNode->data = x;
	return newNode;
}

 此操作为了方便创建新节点，这样的话只要调用此函数就可以创建新的节点了。

4、单链表的打印


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

	while (plist)
	{
		printf("%d->", plist->data);
		plist = plist->next;
	}
}

此函数可以将链表中的数据进行逐个打印出来。

5、单链表的尾插

//单链表的尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	SListNode* newNode = BuyListNode(x);
	SListNode* tail = *pplist;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next = newNode;
	newNode->next = NULL;
}

此函数用于在单链表中进行尾插数据。

6、 单链表的头插

void SListPushFront(SListNode** pplist, SLTDateType x)
{
	SListNode* newNode = BuyListNode(x);
	newNode->next = *pplist;
	*pplist = newNode;
}

此函数用于在单链表的头部进行插入数据。 

7、单链表的尾删

//单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);
	SListNode* tail = *pplist;
	SListNode* prev = NULL;
	if (tail == NULL || tail->next == NULL)
	{
		free(tail);
		*pplist = NULL;
	}
	else
	{
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		/*if (prev == NULL)
			return NULL;*/
		prev->next = NULL;
		free(tail);
		tail = NULL;
		
	}

	
}

此函数用于单链表的尾删。

8、 单链表的头删

//单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);
	SListNode* cur = *pplist;
	if (*pplist == NULL)
	{
		return;
	}
	else if (cur->next == NULL)
	{
		free(cur);
		*pplist = NULL;
	}
	else
	{
		*pplist = cur->next;
		free(cur);
	}
}

此函数用于单链表的头删。

9、单链表的查找

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

 此函数可以在单链表中遍历用来查找你要查找的数据。

10、在pos之后插入数据

//单链表在pos位置之后插入x
//分析思考为什么不在pos位置之前插入？
//因为单链表的指向是单一的 只能指向后一个位置
//所以如果在pos前边插入 将非常复杂
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	SListNode* newNode = BuyListNode(x);
	SListNode* cur = NULL;
	cur = pos;
	if (cur->next == NULL)
	{
		SListPushBack(&pos, x);
	}
	newNode->next = cur->next;
	cur->next = newNode;
}

11、在pos之后删除数据


//单链表删除pos位置之后的值
//分析思考为什么不删除pos位置？
//答案同上
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	//pos next nextnext
	SListNode* next = pos->next;
	if (next != NULL)
	{
		SListNode* nextnext = next->next;
		free(next);
		pos->next = nextnext;
	}
}

12、单链表的销毁

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

13、完整代码

我们可以分别创建一个 slist.c   一个 test.c  一个  slist.h  。分别用来存放代码，使代码更加清晰。

slist.h 里面存放函数的定义和一些头文件的包含。

slist.c 里面来存放函数的实现。

test.c 里面来存放你所需要测试的每个函数。

slist.c

代码如下：

#include"slist.h"

//动态申请一个节点
SListNode* BuyListNode(SLTDateType x)
{
	SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));
	if (newNode == NULL)
		return NULL;
	newNode->data = x;
	return newNode;
}

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

	while (plist)
	{
		printf("%d->", plist->data);
		plist = plist->next;
	}
}

//单链表的尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	SListNode* newNode = BuyListNode(x);
	SListNode* tail = *pplist;
	while (tail->next != NULL)
	{
		tail = tail->next;
	}
	tail->next = newNode;
	newNode->next = NULL;
}


//单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	SListNode* newNode = BuyListNode(x);
	newNode->next = *pplist;
	*pplist = newNode;
}

//单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist);
	SListNode* tail = *pplist;
	SListNode* prev = NULL;
	if (tail == NULL || tail->next == NULL)
	{
		free(tail);
		*pplist = NULL;
	}
	else
	{
		while (tail->next)
		{
			prev = tail;
			tail = tail->next;
		}
		/*if (prev == NULL)
			return NULL;*/
		prev->next = NULL;
		free(tail);
		tail = NULL;
		
	}

	
}

//单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(pplist);
	SListNode* cur = *pplist;
	if (*pplist == NULL)
	{
		return;
	}
	else if (cur->next == NULL)
	{
		free(cur);
		*pplist = NULL;
	}
	else
	{
		*pplist = cur->next;
		free(cur);
	}
}

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


//单链表在pos位置之后插入x
//分析思考为什么不在pos位置之前插入？
//因为单链表的指向是单一的 只能指向后一个位置
//所以如果在pos前边插入 将非常复杂
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	SListNode* newNode = BuyListNode(x);
	SListNode* cur = NULL;
	cur = pos;
	if (cur->next == NULL)
	{
		SListPushBack(&pos, x);
	}
	newNode->next = cur->next;
	cur->next = newNode;
}


//单链表删除pos位置之后的值
//分析思考为什么不删除pos位置？
//答案同上
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	//pos next nextnext
	SListNode* next = pos->next;
	if (next != NULL)
	{
		SListNode* nextnext = next->next;
		free(next);
		pos->next = nextnext;
	}
}

//单链表的销毁
void SListDestory(SListNode* plist)
{
	SListNode* cur = plist;
	SListNode* next = NULL;
	while (cur)
	{
		next = cur->next;
		free(cur);
		cur = NULL;
		next = next->next;
	}
}

slist.h

代码如下：

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

typedef int SLTDateType;

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

//动态申请一个节点
SListNode* BuyListNode(SLTDateType x);

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

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

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

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

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

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

//单链表在pos位置之后插入x
//分析思考为什么不在pos位置之前插入？
//因为单链表的指向是单一的 只能指向后一个位置
//所以如果在pos前边插入 将非常复杂
void SListInsertAfter(SListNode* pos, SLTDateType x);

//单链表删除pos位置之后的值
//分析思考为什么不删除pos位置？
//答案同上
void SListEraseAfter(SListNode* pos);

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

test.c

代码如下：

#include"slist.h"

void Test1()
{
	SListNode* phead = NULL;
	SListPushFront(&phead, 1);
	SListPushFront(&phead, 2);
	SListPushFront(&phead, 3);
	/*SListPushBack(&phead, 1);
	SListPushBack(&phead, 2);
	SListPushBack(&phead, 3);*///321123
	/*SListPopBack(&phead);
	SListPopBack(&phead);
	SListPopBack(&phead);*/
	/*SListPopFront(&phead);*/
	SListPrint(phead);
	SListInsertAfter(phead,3);
	printf("\n");
	SListPrint(phead);

	SListDestory(phead);

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

14、结尾

上述代码若有遗漏错误指出，希望兄弟们能指出，互相学习，互相进步。也感谢兄弟们的观看，感谢！

袁百万
关注
专栏目录
单链表实现
forwardjia的博客
01-21 1221
线性表的链式存储：用一组任意的存储单元存放线性表的数据元素（这组存储单元可以连续，也可不连续）。为表示数据元素之间的逻辑关系，还需有存储一个指示后继的信息—— 指针。由数据域和指针域构成数据元素的存储映象，称为结点。 单链表包括两个域：数据域用来存储结点的值；指针域用来存储数据元素的直接后继的地址（或位置）。链表正是通过每个结点的指针域将线性表的n个结点按其逻辑顺序链接在一起。由于链表的每个结点只有一个指针域，故将这种链表又称为单链表 简单实现方式： #define _CRT_SECURE.
单链表的实现
qq_41134008的博客
08-20 154
一、单链表思想： 1）、链表是一种重要的数据结构，是一种数据的存储方式。链表由多个链表元素组成， 每个元素称为节点，链表存储的物理结构可能是连续的，但也有可能是无序的。但是链表之间的元素是有序的逻辑相连。 2）、代码演练：创建一个链表，实现增删改查等孤等功能。 ...
Python单链表简单实现代码
09-21
### Python单链表简单实现详解 #### 一、引言 在计算机科学中，链表是一种常见的线性数据结构，其特点是元素之间的物理位置不必连续。链表中的每个元素（通常称为节点）由两部分组成：存储数据的数据段和指向下一个...
单链表的实现-简单操作
11-18
单链表的实现-简单操作
基于JAVA的单链表简单实现
01-05
在Java中，我们可以使用对象和引用的概念来实现单链表。 首先，我们需要创建一个表示链表节点的类Node，它通常有两个属性：data（用于存储数据）和next（用于存储指向下一个节点的引用）。例如： ```java public ...
C语言单链表的实现
12-08
做了个简单的单链表实现，基本的功能都齐全了。而且我习惯附上详细的注释，应该对初学者蛮友好的了。
php实现一个单链表
03-05 90
　　单链表，节点只有一个指针域的链表。节点包括数据域和指针域。 　　因此用面向对象的思维，节点类的属性就有两个：一个data（表示存储的数据），一个指针next（链表中指向下一个节点）。 　　链表一个很重要的特性，就是这个头节点$head。它绝对不能少，每次遍历都要从它开始，并且不能移动头节点，应该用一个变量去代替他移动。脑袋里要有链表的结构。这是关键。 　　来一段代码： 　　 ...
单链表简单实现
LJ11699的博客
10-19 138
单链表的形式：头部有个head节点每个节点都向后关联一个节点 下面是我的单链表的插删改查和反转的操作： #include<stdio.h> #include<stdlib.h> #include<malloc.h> typedef struct Node* List; #define NODE_SIZE sizeof(stru...
9-2 单链表的实现
成长的博客
10-21 294
9.2.1 单链表的节点构成 （1）链表是由节点组成的，节点中包含：有效数据和指针。 （2）定义的struct node只是一个结构体，本身并没有变量生成，也不占用内存。结构体定义相当于为链表节点定义了一个模板，但是还没有一个节点，将来在实际创建链表时需要一个节点时用这个模板来复制一个即可。 9.2.2 堆内存的申请和使用 （1）链表的内存要求比较灵活，不能用栈，也不能用data数据段。只能用堆内存。 （2）使用堆内存来创建一个链表节点的步骤：1、申请堆内存，大小为一个节点的大小（检查申请结果是否正确）；
实现单链表
diantangchuo4915的博客
07-05 106
因为在传递函数参数时，使用了引用，所以该程序为C++程序 #include <stdio.h>#include <stdlib.h>#define ElemType inttypedef struct LNode{ ElemType data; struct LNode *next; int length;}LNode, *LinkList;i...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

袁百万

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

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

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

打赏作者

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

抵扣说明：

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

余额充值