单链表的基本实现

岁寒枝.

已于 2024-03-15 16:55:34 修改

阅读量916

点赞数 24

文章标签：链表数据结构

于 2024-03-15 16:46:34 首次发布

本文链接：https://blog.csdn.net/2301_79686315/article/details/136660133

版权

一.为什么要实现链表？

因为顺序表存在一定的问题：

1.顺序表的中间/头部的插入，删除数据需要挪动其它数据

2.扩容存在性能的消耗

3.会有空间的浪费

因此我们需要一个更高效的数据结构来存储数据->链表

链表由独立的节点构成

节点：node 指向第一个节点的指针：plist SLTNode* plist = node；

前驱节点指针：prev 遍历节点指针：pcur

实参形参

node **pphead

plist *pphead 指向第一个节点的指针

&plist pphead

二.链表的概念及结构

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

结构：

可以看出：①链表可以分成两部分，一是存储的数据，二是存储了下一个节点的地址。

②链式结果是在逻辑上是连续的，在物理结构是不是连续的。

三.链表的分类

实际中，链表分为：

①.单向 or 双向

②.带头 or 不带头

③.循环 or 不循环

今天，我们只实现的不带头不循环单向链表，结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构。

四.无头单向非循环链表的实现

为了养成模块化好习惯，全部代码将分为SList.h用来存放头文件，创建节点和要实现的函数，SList.h用来具体实现函数，test.c用来测试代码。

一.节点的创建

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** pphead, SLTDataType x);//查找
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);//指定位置之前插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);//指定位置之后插入数据
void SLTErase(SLTNode** pphead, SLTNode* pos);//删除指定位置的数据
void SLTEraseAfter(SLTNode* pos);//删除指定位置之后的数据
void SListDestory(SLTNode** pphead);//销毁链表

接下来，我们开始逐一实现。

①.创建新节点

SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = NULL;
	if (newnode == NULL)//代码健壮性更高
	{
		perror("malloc fail");
		exit(-1);
	}
	return newnode;
}

每次插入新数据，都要创建新节点用malloc开辟一个与链表的其它节点大小相同的新节点，if()判断新节点是否创建成功，也可以用assert断言判断。

②.尾插

void SLTPushBack(SLTNode** pphead, SLTDataType x)//传地址
{
	assert(pphead);
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = NULL;
	//链表为空
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}
	//链表不为空
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	ptail->next = newnode;
}

尾插我们要考虑的情况有两种，1.链表为空，直接尾插。

2.链表不为空，要找到尾节点，然后再尾插。

同时要判断assert（pphead）不能为空，为空的话就意味着这个链表不存在。

③.头插

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

头插虽然也有链表为空和链表不为空两种情况，但这两种情况的处理方法是一样的。

④.打印链表

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

为了实现打印，我们需要遍历链表，但是不能直接用我们传过来的头指针，因为在这里我们实现的是单向链表，如果让头指针移动，我们就会发现我们找不到头节点了。所以我们在这里创建一个指针让他指向头节点，也就是让pcur指针去遍历链表，当pcur->next为空指针时，pcur指向的是尾节点，刚好打印完整个链表。

⑤.尾删

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	//链表不能为空
	assert(*pphead);//指向第一个节点的地址
	if ((*pphead)->next == NULL)//只有一个节点
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}
		SLTNode* ptail = *pphead;
		SLTNode* prev = NULL;
		while (ptail->next)//有多个节点
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
}

尾删分为三种情况1.链表为空，这种情况不发尾删，所以可以直接使用断言。

2.链表只有一个节点，我们直接释放这节点存储的数据，并让它指向空NULL;

3.链表有多个节点，这时我们要考虑链表指针的指向。

尾插因为要找到尾节点，不可避免的需要遍历链表。

⑥.头删

void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	SLTNode* next = (*pphead)->next;//->的优先级大于*，因此要加括号
	free(*pphead);
	*pphead = next;
}

头插的实现逻辑很简单，我们将头指针*pphead->next存储在新创建的指针next中，然后释放头指针，再让*pphead = next（这就相当于让头指针向前走了）。

⑦.查找（通过节点存储的数据）

SLTNode* SLTFind(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* pcur = *pphead;
	while (pcur)//pcur不等价于NULL
	{
		if (pcur->data == x)
		{
			//找到了
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}

这个函数与其它函数不同在于，这个函数是有返回值的，这个返回值的类型是SLTNode也就是要返回一个指针。

实现逻辑很简单，遍历链表，在循环中让输入的数据和链表中存储的数据比较，如果找到了就返回pcur，如果没有找到就返回一个空指针。

⑧.在指定位置之前插入数据

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	//链表不能为空
	assert(*pphead);

	SLTNode* newnode = SLTBuyNode(x);
   //pos指向头节点
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);
		return;
	}
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;
}

这个函数我们发现，存在三个断言，我们之前的函数一般只会断言assert（pphead）直言保证这个链表存在就行了，但是现在我们要assert（pos）保证指定位置的节点存在，在pos存在的前提下，这个链表就不可能是一个空链表（因为至少保证了存在pos这个节点）。

同样分为两种情况来插入数据：1.pos指向的是头节点，直接调用头插函数。

2.pos指向的不是头节点，遍历链表。

⑨.在指定位置之后插入数据

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

这个函数的实现就很好理解了，因为链表的一个节点是可以直接找到下一个节点的。

⑩.删除指定位置的节点

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);


	//pos刚好是头节点
	if (*pphead == pos)
	{
		SLTPopFront(pphead);
		return;
	}
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;
	return;
}

分两种情况：1.pos刚好是头节点，调用头删函数。

2.pos不是头节点，遍历链表，这里要注意删除链表前，应该先要连接删除节点的前后两个节点。

11.删除指定节点后的节点

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

因为节点可以直接指向下一个节点嘛，使用直接让它指向next。

12.销毁链表

void SListDestory(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}

因为链表是逻辑线性，我们在销毁链表的时候要一个一个节点销毁，这时候就要遍历链表，最后让头指针指向空。

五.完整代码

一.SLlist.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.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** pphead, SLTDataType x);//查找
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);//指定位置之前插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x);//指定位置之后插入数据
void SLTErase(SLTNode** pphead, SLTNode* pos);//删除指定位置的数据
void SLTEraseAfter(SLTNode* pos);//删除指定位置之后的数据
void SListDestory(SLTNode** pphead);//销毁链表

二.SLlist.c

#include "SList.h"

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


SLTNode* SLTBuyNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = NULL;
	if (newnode == NULL)//代码健壮性更高
	{
		perror("malloc fail");
		exit(-1);
	}
	return newnode;
}


//尾插数据
//1.链表为空
//2.链表不为空,找到尾节点。
void SLTPushBack(SLTNode** pphead, SLTDataType x)//传地址
{
	assert(pphead);
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;
	newnode->next = NULL;
	//链表为空
	if (*pphead == NULL)
	{
		*pphead = newnode;
		return;
	}
	//链表不为空
	SLTNode* ptail = *pphead;
	while (ptail->next)
	{
		ptail = ptail->next;
	}
	ptail->next = newnode;
}


//头插数据
//链表为空
//链表不为空

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

//尾删数据
//链表不能为空（断言）
//链表只有一个节点
//链表有多个节点

void SLTPopBack(SLTNode** pphead)
{
	assert(pphead);
	//链表不能为空
	assert(*pphead);//指向第一个节点的地址
	if ((*pphead)->next == NULL)//只有一个节点
	{
		free(*pphead);
		*pphead = NULL;
		return;
	}
		SLTNode* ptail = *pphead;
		SLTNode* prev = NULL;
		while (ptail->next)//有多个节点
		{
			prev = ptail;
			ptail = ptail->next;
		}
		prev->next = NULL;
		free(ptail);
		ptail = NULL;
}

//头删
//让第二个节点成为新的头，将要删除的节点释放掉
void SLTPopFront(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);

	SLTNode* next = (*pphead)->next;//->的优先级大于*，因此要加括号
	free(*pphead);
	*pphead = next;
}

//查找（根据数据查找）
SLTNode* SLTFind(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* pcur = *pphead;
	while (pcur)//pcur不等价于NULL
	{
		if (pcur->data == x)
		{
			//找到了
			return pcur;
		}
		pcur = pcur->next;
	}
	//没有找到
	return NULL;
}

//指定位置之前插入数据
//找到pos对应的前驱节点prev
//prev newnode pos 修改对应的指针连接
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead);
	assert(pos);
	//链表不能为空
	assert(*pphead);

	SLTNode* newnode = SLTBuyNode(x);
   //pos指向头节点
	if (*pphead == pos)
	{
		SLTPushFront(pphead, x);
		return;
	}
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = newnode;
	newnode->next = pos;
}

//指定位置之后插入数据
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	SLTNode* newnode = SLTBuyNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}


//删除指定位置的数据
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead);
	assert(pos);
	assert(*pphead);


	//pos刚好是头节点
	if (*pphead == pos)
	{
		SLTPopFront(pphead);
		return;
	}
	SLTNode* prev = *pphead;
	while (prev->next != pos)
	{
		prev = prev->next;
	}
	prev->next = pos->next;
	free(pos);
	pos = NULL;
	return;
}
//删除指定位置之后的数据
void SLTEraseAfter(SLTNode* pos)
{
	assert(pos);
	assert(pos->next);
	SLTNode* del = pos->next;
	pos->next = pos->next->next;
	free(del);
	del = NULL;
}


//销毁链表
void SListDestory(SLTNode** pphead)
{
	assert(pphead);
	assert(*pphead);
	SLTNode* pcur = *pphead;
	while (pcur)
	{
		SLTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	*pphead = NULL;
}