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

目录

• [1. 链表的概念及结构](#1. 链表的概念及结构)
• [2. 实现单链表](#2. 实现单链表)
• [3. 链表的分类](#3. 链表的分类)

1. 链表的概念及结构

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

链表的结构跟火车车厢相似，淡季时车次的车厢会相应减少，旺季时车次的车厢会额外增加几节。只需要将火车里的某节车厢去掉/加上，不会影响其他车厢，每节厢车都是独立存在的。

车厢是独立存在的，且每节车厢都有车门。想象一下这样的场景，假设每节车厢的车门都是锁上的状态，需要不同的钥匙才能解锁，每次只能携带一把钥匙的情况下如何从车头走到车尾？

最简单的做法：每节车厢⾥都放一把下一节车厢的钥匙。

在链表里，每节"车厢"是什么样的呢？

与顺序表不同的是，链表里的每节"⻋厢"都是独立申请下来的空间，我们称之为"结点/节点"。

节点的组成主要有两个部分：当前节点要保存的数据和保存下一个节点的地址（指针变量）。

图中指针变量plist保存的是第⼀个节点的地址，我们称plist此时指向第⼀个节点，如果我们希望plist指向第⼆个节点时，只需要修改plist保存的内容为0x0012FFA0。

为什么还需要指针变量来保存下一个节点的位置？

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

结合前⾯学到的结构体知识，我们可以给出每个节点对应的结构体代码：

假设当前保存的节点为整型：

struct SListNode
{
	int data; //节点数据
	struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};

当我们想要保存一个整型数据时，实际是向操作系统申请了一块内存，这个内存不仅要保存整型数据，也需要保存下一个节点的地址（当下一个节点为空时保存的地址为空）。

当我们想要从第一个节点走到最后一个节点时，只需要在前一个节点拿上下一个节点的地址（下一个节点的钥匙）就可以了。

给定的链表结构中，如何实现节点从头到尾的打印？

思考：当我们想保存的数据类型为字符型、浮点型或者其他自定义的类型时，该如何修改？

• 链式结构在逻辑上是连续的，在物理结构上不一定连续
• 节点一般是从堆上申请的
• 从堆上申请来的空间，是按照一定策略分配出来的，每次申请的空间可能连续，可能不连续

我们可以这样来改善一下代码：

typedef int SLdatatype;//类型重定义
struct SListNode
{
	SLdatatype data; //节点数据
	struct SListNode* next; //指针变量⽤保存下⼀个节点的地址
};

这样一来，如果后续涉及到要存储其他的类型的时候，代码量又比较多的时候，就不需要一个一个的去修改存储的类型了，只需要将typedef后面的类型一键替换就可以了。嘿嘿，是不是很巧妙呀😎

2. 实现单链表

SList.h

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
//定义节点结构
typedef int sldatatype;
typedef struct SListnode
{
	sldatatype data;//数据
	struct SList* next;//指向下一个节点的指针
}Sltnode;
//尾插
void Sltpushback(Sltnode** phead, sldatatype x);
//打印节点
void Sltprint(Sltnode* phead);
//头插
void SltpushFront(Sltnode** pphead, sldatatype x);
//尾删
void SltPopBack(Sltnode** pphead);
//头删
void SltPopFront(Sltnode** pphead);
//查找节点
Sltnode* SltFind(Sltnode* phead, sldatatype x);
//指定位置前插入
void SltInsert(Sltnode** pphead, Sltnode* find, sldatatype x);
//指定位置后插入
void SltInsertafter(Sltnode* pos, sldatatype x);
//删除pos节点
void SltErase(Sltnode** pphead, Sltnode* pos);
//删除pos之后的节点
void SltEraseAfer(Sltnode* pos);
//销毁链表
void ListDestroy(Sltnode** pphead);

SList.c

#define _CRT_SECURE_NO_WARNINGS
#include "SList.h"
//创建一个节点
Sltnode* SltBuynode(sldatatype 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, sldatatype x)
{
	assert(pphead);
	//pphead就是指向第一个节点的指针
	//空链表和非空链表两种情况
	Sltnode* newnode = SltBuynode(x);
	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		//找尾
		Sltnode* ptail = *pphead;
		while (ptail->next)
		{
			ptail = ptail->next;
		}
		//此时ptail指向的就是尾节点
		ptail->next = newnode;
	}
}
//打印节点
void Sltprint(Sltnode* phead)
{
	while (phead != NULL)
	{
		printf("%d->", phead->data);
		phead = phead->next;
	}
	printf("NULL\n");
}
//头插
void SltpushFront(Sltnode** pphead, sldatatype x)
{
	assert(pphead);
	Sltnode* newnode = SltBuynode(x);
	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;
		while (ptail->next != NULL)
		{
			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, sldatatype x)
{
	while (phead)//等价于phead != NULL
	{
		if (phead->data == x)
		{
			return phead;
		}
		phead = phead->next;
	}
	//phead==NULL 
	return NULL;
}
//在指定位置之前插入数据
void SltInsert(Sltnode** pphead, Sltnode* pos, sldatatype x)
{
	assert(pphead && *pphead);
	assert(pos);
	Sltnode* newnode = SltBuynode(x);
	//当pos为头节点时，说明是头插
	if (pos == *pphead)
	{
		SltpushFront(pphead, x);
	}
	//pos不为头节点
	else
	{
		//找pos前一个节点
		Sltnode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		//prev -> newnode -> pos
		newnode->next = pos;
		prev->next = newnode;
	}
}
//在指定位置之后插入数据
void SltInsertafter(Sltnode* pos, sldatatype x)
{
	assert(pos);
	Sltnode* newnode = SltBuynode(x);
	//pos -> newnode -> pos->next
	newnode->next = pos->next;
	pos->next = newnode;
}
//删除pos节点
void SltErase(Sltnode** pphead, Sltnode* pos)
{
	assert(pphead && *pphead && pos);
	//pos是头节点
	if (pos == *pphead)
	{
		//头删
		SltPopFront(pphead);
	}
	else
	{
		//pos不是头节点
		Sltnode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}
//删除pos之后的节点
void SltEraseAfer(Sltnode* pos)
{
	assert(pos && pos->next);
	Sltnode* Del = pos->next;
	pos->next = Del->next;
	free(Del);
	Del = NULL;
}
//销毁链表
void ListDestroy(Sltnode** pphead)
{
	assert(pphead && *pphead);
	while (*pphead)
	{
		Sltnode* pcur = (*pphead)->next;
		free(*pphead);
		*pphead = pcur;
	}
	*pphead = NULL;
}

text.c

#define _CRT_SECURE_NO_WARNINGS
#include "SList.h"
void SListTest()
{
	Sltnode* plist = NULL;
	//测试尾插
	Sltpushback(&plist, 1);
	Sltpushback(&plist, 2);
	Sltprint(plist);
	//SLpushback(NULL,5);
	//测试打印节点
	//Sltprint(plist);
	//测试头插
	//SltpushFront(&plist, 6);
	//Sltprint(plist);
	//测试尾删
	//SltPopBack(&plist);
	//Sltprint(plist);
	//测试头删
	//SltPopFront(&plist);
	//Sltprint(plist);
	//测试查找节点
	//Sltnode* find = SltFind(plist, 3);
	//if (find)
	//	printf("找到了!\n");
	//else
	//	printf("没有找到!\n");
	//测试指定位置前插入
	//SltInsert(&plist, find, 7);
	//Sltprint(plist);
	//测试指定位置后插入
	//SltInsertafter(find,8);
	//Sltprint(plist);
	//测试删除pos节点
	//SltErase(&plist, find);
	//Sltprint(plist);
	//测试删除pos之后的节点
	//SltEraseAfer(find);
	//Sltprint(plist);
	//测试销毁链表
	ListDestroy(&plist);
	Sltprint(plist);
}
int main()
{
	SListTest();
	return 0;
}

3. 链表的分类

链表的结构非常多样，以下情况组合起来就有8种（2x2x2）链表结构：

链表说明：

1. 单向或者双向
   
2. 带头或者不带头
   
3. 循环或者不循环
   
   虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表 和 双向带头循环链表。

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结
   构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试⾯试中出现很多。
2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都
   是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带
   来很多优势，实现反而简单了，后面等我们双向链表代码实现完就知道了。

---

下期会讲解双向链表的概念和结构以及双向链表代码的实现哟！如果对你有所帮助，别忘了给博主点个小小的赞和关注哟，谢谢宝子们！😽