【数据结构】--单链表的实现

Alan编程

已于 2024-05-22 17:28:56 修改

阅读量1k

点赞数 24

分类专栏：数据结构文章标签：数据结构

于 2024-05-22 16:34:10 首次发布

本文链接：https://blog.csdn.net/2301_78009847/article/details/138925969

版权

数据结构专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一.链表的概念及结构

1.链表的概念

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

2.链表的结构

链表的结构跟⽕⻋⻋厢相似，淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。只需要将⽕⻋⾥的某节⻋厢去掉或加上，不会影响其他⻋厢，每节⻋厢都是独⽴存在的。

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

3.链表节点的定义

//定义节点的结构
//节点 == 数据 + 指向下一个节点的指针
typedef int SLTDataType;
typedef struct SListNode
{
	SLTDataType data;//当前节点要保存的数据
	struct SListNode* next;//指向下一个节点的指针
}SLNode;

当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数
据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址就可以了。

二.单链表的实现

1.定义节点

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;//当前节点要保存的数据
	struct SListNode* next;//指向下一个节点的指针
}SLNode;

2.申请节点

SLTNode* SLTBuyNode(SLTDataType x)
{
	//动态申请空间
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

3.打印单链表

这里可以遍历链表，用一个指针指向头节点，当头节点不为空就打印节点中的数据并让指针指向下一个节点，当指针指向的节点为空时，退出循环。

//打印单链表
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcure = phead;
	while (pcure)
	{
		printf("%d->", pcure->data);
        pcure = pcure->next;
	}
	printf("NULL\n");
}

4.单链表尾插

首先申请一个新的节点newnode。如果头节点为空，那就让新节点成为新的头节点。若头节点不为空，则遍历链表找到链表的尾节点pptial，让链表尾节点的next指向newnode（注意：在申请新节点的时候已经让节点的next == NULL，所以这里不需要再让next的指针指向空）。

需要注意的是，这里函数的形参用的是二级指针，因为当单链表为空时，头指针指向的是NULL，当插入新节点后，需要让头节点指向新节点，所以需要用二级指针。（注意：如果用一级指针，就相当于传值，我们知道实参传值，形参的改变不会影响实参）。可以根据此图来理解。

void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
        //找尾
		SLTNode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		ptail->next = newnode;
	}
}

5.单链表头插

首先申请一个新的节点newnod。先让newnode->next = *pphead,再让newnode成为新的头节点。（链表为不为空都是一样的）。

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

6.单链表尾删

单链表尾删当链表不为空时，若链表有多个节点则遍历链表找到链表尾节点的前一个节点SLTNode* prve，然后让prve->next =NULL,最后释放掉尾节点的空间，若链表只有一个节点直接释放掉节点的空间。当链表为空时直接报错并退出程序。

void SLTPopBack(SLTNode** pphead)
{
	//链表不能为空
	assert(pphead && *pphead);
	//只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//多个节点
	{
		SLTNode* pcur = *pphead;
		SLTNode* plist = *pphead;
		while (plist->next)
		{
			pcur = plist;
			plist = plist->next;
		}
		pcur->next = NULL;
		free(plist);
		plist = NULL;
	}
}

7.单链表头删

头删首先要保证链表不能为空。当链表不为空时，首先用一个指针next来保存头节点的下一个节点，然后释放掉头结点，并让头节点指向next指向的节点。

void SLTPopFront(SLTNode** pphead)
{
	//链表不能为空
	assert(pphead && *pphead);
	//保存头节点的下一个节点
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

8.单链表查找

当链表不为空时，通过遍历链表判断当前节点所保存的数据与要查找的数据是否相同，若相同则返回当前节点的地址，若遍历完链表仍未找到则返回NULL。

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

9.在指定位置pos之后插入

在pos之后插入数据首先通过查找接口获得pos所指向的节点位置，接着申请一个新的节点newnode，断开pos与pos->next的连接，让pos newnode pos->next 三个节点相互连接。

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

10.在指定位置pos之前插入

在pos之前插入数据，若pos指向头节点其操作相当于头插操作，可以直接调用头插。若pos没有指向头节点，则首先通过查找接口获得pos所指向的节点位置，接着申请一个新的节点newnode，其次通过遍历链表找到pos的前一个节点prve。最后让 prve newnode pos 相互连接。

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
    //pos指向头节点的时候
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prve = *pphead;
		while (prve->next != pos)
		{
			prve = prve->next;
		}
		//prve  newnode  pos
		prve->next = newnode;
		newnode->next = pos;
	}
}

11.删除pos节点

删除pos节点会影响pos的前一个和后一个节点，首先需要先找到pos的前一个节点prve和后一个节点pos->next，接着让prve的next指向pos->next，最后在释放掉pos节点的空间。

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* prve = *pphead;
	//pos指向头节点的时候
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		while (prve->next != pos)
		{
			prve = prve->next;
		}
		//prve  pos  pos->next
		prve->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

12.删除pos之后的节点

删除pos之后的节点需要改变的是pos pos->next pos->next->next三个节点位置。让pos指向pos->next->next,最后释放掉pos->next的空间。

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

13.销毁链表

由于链表在物理结构上是不连续存储的，所以销毁链表需要通过遍历链表依次释放掉每一个节点。

最后不要忘记把头节点置为NULL。

void SLTDesTroy(SLTNode** pphead)
{
	assert(pphead && *pphead);
	SLTNode* prve = *pphead;
	while (prve)
	{
		SLTNode* next = prve->next;
		free(prve);
		prve = next;
	}
	*pphead = NULL;
}

三.完整代码

SList.h

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

SList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

//打印单链表
void SLTPrint(SLTNode* phead)
{
	SLTNode* pcure = phead;
	while (pcure)
	{
		printf("%d->", pcure->data);
		pcure = pcure->next;
	}
	printf("NULL\n");
}

SLTNode* SLTBuyNode(SLTDataType x)
{
	//动态申请空间
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail!");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	assert(pphead);
	SLTNode* newnode = SLTBuyNode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		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  *pphead
	newnode->next = *pphead;
	*pphead = newnode;
}

//尾删
void SLTPopBack(SLTNode** pphead)
{
	//链表不能为空
	assert(pphead && *pphead);
	//只有一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else//多个节点
	{
		SLTNode* pcur = *pphead;
		SLTNode* plist = *pphead;
		while (plist->next)
		{
			pcur = plist;
			plist = plist->next;
		}
		pcur->next = NULL;
		free(plist);
		plist = NULL;
	}
}

//头删
void SLTPopFront(SLTNode** pphead)
{
	//链表不能为空
	assert(pphead && *pphead);
	//保存头节点的下一个节点
	SLTNode* next = (*pphead)->next;
	free(*pphead);
	*pphead = next;
}

//查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	assert(phead);
	SLTNode* pcur = phead;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		else
		{
			pcur = pcur->next;
		}
	}
	return NULL;
}

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

//在指定位置之前插入数据
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* newnode = SLTBuyNode(x);
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x);
	}
	else
	{
		SLTNode* prve = *pphead;
		while (prve->next != pos)
		{
			prve = prve->next;
		}
		//prve  newnode  pos
		prve->next = newnode;
		newnode->next = pos;
	}
}

//删除pos节点
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pphead && *pphead);
	assert(pos);
	SLTNode* prve = *pphead;
	//pos指向头节点的时候
	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		while (prve->next != pos)
		{
			prve = prve->next;
		}
		//prve  pos  pos->next
		prve->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

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

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

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"

void test()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPrint(plist);
	//SLTPushFront(&plist, 5);
	//SLTPushFront(&plist, 6);
	//SLTPrint(plist);
	//SLTPopBack(&plist);
	//SLTPopBack(&plist);
	//SLTPopBack(&plist);
	//SLTPopBack(&plist);
	//SLTPopFront(&plist);
	//SLTPopFront(&plist);
	//SLTPopFront(&plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	SLTNode* find = SLTFind(plist, 1);
	if (find != NULL)
	{
		printf("找到了！\n");
	}
	else
	{
		printf("未找到！\n");
	}
	//SLTInsertAfter(find, 100);
	//SLTPrint(plist);
	//SLTInsert(&plist, find, 100);
	//SLTPrint(plist);
	//SLTErase(&plist, find);
	//SLTPrint(plist);
	SLTEraseAfter(find);
	SLTPrint(plist);
}


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

感谢大家阅读我的文章，喜欢我的文章的话就点个赞+关注再走吧！后续会持续更新的！

下次见！see you！

Alan编程

关注

24
点赞
踩
15

收藏

觉得还不错? 一键收藏
6
评论
【数据结构】--单链表的实现

/定义节点的结构//节点 == 数据 + 指向下一个节点的指针//当前节点要保存的数据//指向下一个节点的指针}SLNode;当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。当我们想要从第⼀个节点⾛到最后⼀个节点时，只需要在前⼀个节点拿上下⼀个节点的地址就可以了。//当前节点要保存的数据//指向下一个节点的指针}SLNode;
复制链接

扫一扫