单链表的实现

酷酷的崽798

于 2024-06-30 14:11:37 发布

阅读量1k

点赞数 30

文章标签： c语言数据结构

本文链接：https://blog.csdn.net/ZWW_zhangww/article/details/140078919

版权

链表的概念及结构

概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

我对于链表的理解：链表其实就是顺序表的升级版，对顺序表的优化让程序的工作效率更加高效。

我的上一篇文章当中有着这样的定义在头文件当中

但是在链表当中我们需要定义一个结构体指针去寻找我们需要寻找的位置

同样的SLTDataType是我们重新定义的以一种类型可以统一方便修改

那么话说回来，我们为什么需要定义一个结构体指针呢？

1.上图是一辆火车，火车是由一节节的车厢组成的，每一节车厢都是有他们自己所属于的编号，把他们有规律的一节节的串联起来，而我们所说的链表也是如此，通过一个个的地址将数据给连接起来，方便我们的增删查改，

2.链表中每个节点都是独⽴申请的（即需要插⼊数据时才去申请⼀块节点的空间），我们需要通过指针变量来保存下⼀个节点位置才能从当前节点找到下⼀个节点。

与顺序表不同的是，链表⾥的每节"⻋厢"都是独⽴申请下来的空间，我们称之为“结点/节点” 节点的组成主要有两个部分：当前节点要保存的数据和保存下⼀个节点的地址（指针变量）。图中指针变量plist保存的是第⼀个节点的地址，我们称plist此时“指向”第⼀个节点，如果我们希望plist“指向”第⼆个节点时，只需要修改plist保存的内容为0x0012FFA0。

这两张图片形象的说明了钩子就是我们链表里面的地址，而车厢则是节点，车厢里面的人则是链表中的数据

所以进入主题开始链表的实现

下面是链表所需要的头文件定义的函数，下面我将对这些函数一个一个进行解答。

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


//定义节点的结构
//定义指向下一个节点的指针
typedef int SLTDataType;//所有类型都可以进行修改
typedef struct SListNode
{
	SLTDataType data;//保存的数据
	struct SListNode* next;//下一个节点的位置
}SLTNode;

//打印
void SLTPrint(SLTNode* phead);
//扩容创建一个新节点
SLTNode* SLTBuyNode(SLTDataType x);
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x);
//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x);
//尾删
void SLTPopBack(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);
//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos);
//销毁链表
void SListDesTroy(SLTNode** pphead);

链表的打印

//打印
void SLTPrint(SLTNode* phead)//plist是第一个节点的地址，用一级指针接收
{
	SLTNode* pcur = phead;//用pcur接受第一个节点的位置即plist
	while(pcur)//遍历
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;//用pcur接受下一个地址
                          //我们可以认为pcur是钩子1，而pcur->next是钩子2
	}
	printf("NULL\n");
}
//下面的代码即是测试文件
int main()
{
    SLTNode* plist = NULL;
    SLTPrint（plist）;//plist保存的是第一个节点的位置
	return 0;
}

链表的增容

在进行头插，尾插等插入的时候需要创建新节点，用于新数据的接收

//扩容创建一个新节点
SLTNode*SLTBuyNode(SLTDataType x)//扩容的小大是结构体的大小
                  //SLTDataType x这个是需要创建新节点后保存的数据
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));//类型为SLTNode*
	if (newnode == NULL)//判断节点是否成功创建
	{
		perror("molloc fail!");
		exit(1);//非零强制退出
	}
	newnode->data = x;
	newnode->next = NULL;
	//返回节点
	return newnode;
}

接下来将进行我们链表的正式开始

尾插

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	//*pphead表示指向第一个节点的地址
	SLTNode* newnode = SLTBuyNode(x);//上面扩容返回值是newnode,重新用newnode接收
	//空链表和非空链表
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		SLTNode* ptail = *pphead;
		while (ptail->next)//ptail->next！=NULL
		{
			ptail = ptail->next;//就是最后一个没有使用的火车钩子
		}
		//ptail指向的就是尾结点
		ptail->next = newnode;//新火车车厢的钩子跟没有使用的钩子相连接
	}
}

结合尾插和打印我们有如下的测试结果

void SLTPushBack(SLTNode** pphead, SLTDataType x)

//很多人表示困惑的地方是为什么用二级指针去接收，原因是plist本身是一个地址

如果想要修改指针本身的值，也就是地址，则应使用比原指针高一级的指针来实现

头插

//头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);//newnode是data和next的结合

	newnode->next = *pphead;
	*pphead = newnode;
}
//头插不需要判断是否为非空链表

尾删

//尾删
void SLTPopBack(SLTNode** pphead)
{
	assert(*pphead && pphead);
	//只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//有多个节点
	{
		SLTNode* prev = *pphead;
		SLTNode* ptail = *pphead;//ptail就是上一个节点后面的地址，
                                //即是火车车厢的上一个车厢与最后一个车厢相连接的钩子
		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)
{
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

我们需要找的数字是1，找到输出找到了，否则输出没有找到！

以上就是最基本的一些关于链表的实现

下面我们将进行指定位置的插入和删除

在指定位置之前插入数据

//在指定位置之前插⼊数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	SLTNode* prev = *pphead;
	//若*pphead==pos,则说明是头插
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		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;
}

删除pos节点

可以理解为减掉那一节的车厢

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(*pphead && 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之后的节点

//删除pos之后的节点
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos && pos->next);
	SLTNode* del = pos->next;

	pos->next = del->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

#include"SList.h"

void SListTest01()
{
	//链表是由一个一个的节点组成的
	//创建几个节点
	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;

	//将4个链表连接起来

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

	//调用链表打印
	SLTNode* plist = node1;
	SLTPrint(plist);
}


void SListTset02()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);

	测试头插
	//SLTPushFront(&plist, 6);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 7);
	//SLTPrint(plist);
	//SLTPushFront(&plist, 8);
	//SLTPrint(plist);

	测试尾删
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPrint(plist);
	SLTPopBack(&plist);

	测试头删
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	/*SLTNode* find = SLTFind(plist, 1);*/

	/*SLTInsert(&plist, find, 10);
	SLTPrint(plist);
	find = SLTFind(plist, 1);
	SLTInsert(&plist, find, 8);
	SLTPrint(plist);*/

	//if (find == NULL)
	//{
	//	printf("没有找到\n");
	//}
	//else
	//{
	//	printf("找到了！\n");
	//}
	SLTNode* find = SLTFind(plist, 1);

	/*SLTInsertAfter(find, 11);
	SLTPrint(plist);*/

	/*SLTErase(&plist, find);
	SLTPrint(plist);*/

	SLTEraseAfter(find);
	SLTPrint(plist);

}
int main()
{
	//SListTest01();
	SListTset02();
	return 0;
}