C语言数据结构-链表

1.单链表

1.1概念与结构

数据结构是存储并管理数据。

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

1.2结点

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

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

链表结点的组成部分：要存储的数据+保存下一个结点地址的指针。

图中指针变量plist保存的是第一个结点的地址，我们称plist此时“指向”第一个结点，如果我们希望plist“指向”第二个结点时，只需要修改plist保存的内容为0x0012FFA0.

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

指向下一个结点的地址，就可以找到下一个结点。

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

typedef int SLTDateType;
typedef struct SListNode
{
	SLTDateType data;//结点数据
	struct SListNode* next;//指针变量用保存下一个结点的地址，用的是指针，指向下一个节点的指针，下一个结点的类型也是结构体
}SListNode;

3.2 链表性质

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

数组：数据与数据之间的地址是连续的。
链表：数据与数据之间的地址不一定是连续的。

链表也是线性表的一种。

逻辑结构：一定是线性的。
物理结构：不一定是线性的。

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

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

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

1.3链表的打印

链表实现从头到尾打印：

listnode.c:

// 单链表打印
void SListPrint(SListNode* plist)
{
	SListNode* pcur = plist;
	while (pcur != NULL)
	{
		printf("%d-> ", pcur->data);
		pcur = pcur->next;/将pcur移动到下一个结点
		//把下一个节点的地址给了pcur，就相当于移动到下一个结点了。
	}
	printf("NULL\n");

在这里直接使用plist来遍历结果也是一样的，重新创建个pcur指针，是为了避免由于指针指向的改变，导致无法重新找到链表的首结点。

链表同样也有增删改查等操作，接下来我们来实现单链表的头插和尾插

1.4实现单链表

1.4.1 插入

要插入，就要向操作系统申请结点大小的空间，存储要插入的数据。不论是头插还是尾插，都需要向操作系统申请结点大小的一块空间，所有将向操作动态申请一块空间，分装成一个函数：

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
	if (newnode == NULL)
	{
		perror("malloc fail!\n");
		exit(1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

需要注意的是：
传值：形参的改变不会影响实参
传地址：形参的改变影响实参

接受一级指针的地址用二级指针

// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);
	if (*pplist == NULL)
	{
	//如果pplist为空，那么申请的结点就为首节点，直接将首节点指向*pplist
		//链表为空
		*pplist = newnode;
	}
	else
	{
		//非空
		SListNode* ptail = *pplist;//防止找不到头节点
		首先我们要先找到该链表的尾节点。
		while (ptail->next)
		{
			ptail = ptail->next;//相当于遍历，挪过去了 .
		}
		ptail->next = newnode;
	}
}

时间复杂度为：O（n）

如果只传一级指针，函数内部修改这个指针并不会影响到函数外部的指针；传二级指针就不同了。二级指针指向的是头指针的地址。在函数内部通过二级指针修改头指针的值，就可以真正改变头指针的值，使得在函数外部也可以看到链表头指针的更新。

// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SListNode* newnode = BuySListNode(x);//申请一个节点.
	newnode->next = *pplist;//指向第一个节点的指针
	*pplist = newnode;//现在的头节点是nednode了，将pplist指向newnode。
}

时间复杂度为：O（1）

1.4.2删除

// 单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(pplist&&*pplist);//链表不能为空，就是指向链表第一个结点的指针不能为空
	//要删除尾节点，就需要找到尾节点，需要遍历。
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else {
	//需要定义一个游标，将尾节点的前一个结点保存下来，然后直接将NULL指向游标，就是删除了。
		SListNode* pcur = NULL;
		SListNode* ptail = *pplist;
		while (ptail->next)
		{
		//赋值
			pcur = ptail;
			ptail = ptail->next;
		}
		pcur->next = NULL;
		free(ptail);
		ptail = NULL;
	}
}

// 单链表头删
void SListPopFront(SListNode** pplist)//** pplist是第一个结点
{
	assert(pplist && *pplist);//传过来的参数不能为空，链表不能为空
	SListNode* next = (*pplist)->next;//先将下一个结点保存下来。
	free(*pplist);//释放掉原来的头节点
	*pplist = next;
}

1.4.3查找

// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)//不要求形参发生改变，所以传一级指针就可以了
{
	SListNode* pcur = plist;
	while (pcur)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur=pcur->next;//相当于++
	}
	return NULL;//未找到
}

1.4.4在指定位置之前插入或删除

在指定位置之前插入会改变pos之前和pos位置的结点，所以需要将po之前的结点保存下来。

// 在pos的前面插入
void SLTInsert(SListNode** pplist, SListNode* pos, SLTDateType x)//需要改变形参，传入二级指针
{
	assert(pos&&pplist);
	if (pos == *pplist)//头插
	{
		SListPushFront(pplist, x);
	}
	else {
		SListNode* newnode = BuySListNode(x);
		SListNode* prev = *pplist;
		while (prev->next != pos)
		{
			prev = prev->next;
		}
		newnode->next = pos;
		prev->next = newnode;
	}
}

1.4.5在指定位置之后插入或删除

//插入
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x)//不需要知道头结点也可以。
{
	assert(pos);
	SListNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

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

1.4.6删除指定位置

// 删除pos位置
void SLTErase(SListNode** pplist, SListNode* pos)
{
	assert(pos&&pplist);
	//头删
	if (pos==*pplist)
	{
		SListPopFront(pplist);
	}
	else {
		SListNode* pre = *pplist;//保存头结点
		while (pre->next != pos)//向后遍历
		{
			pre = pre->next;
		}
		pre->next = pos->next;//将pre->next指向pos->next，就将pos删除了。
		free(pos);//释放pos的内存
		pos = NULL;
	}
}

1.4.7销毁链表

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

2.链表的分类

链表的结构非常多样：

链表的说明：

①单向或双向：
单向是只能从左往右遍历；
双向是既能从左往右遍历，也能从右往左遍历。

双向链表有三个，指向前一个结点的指针（前驱结点），指向后一个结点的指针（后继结点）和数据域。

②带头或者不带头：
在前面说的单链表中的“头结点”，该头结点是链表的首节点（第一个结点），实际这样的称呼是错误的，因为链表中存在一种链表叫做带头链表（不是指链表里第一个有效的结点），这里的头结点指的是，哨兵位（不保存任何有效数据，只是占位置的）。

如带头链表中，只有头结点，那么我们就称该链表为空。

带头链表的意义就是：占位置，不需要判断链表的头是否为空。

③循环或者不循环
循环链表的尾结点不为空，指向第一个有效的结点。

…

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

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

3.双向链表

3.1实现双向链表

结点由三个部分组成：
前驱结点、后驱结点和数据。

3.1.1尾插

//尾插
void LTPushBack(LTNode* phead, LTDatatype x)
{
	//为什么这里传的是一级指针？
	//pphead不会发生改变，哨兵位的地址不会改变。
	//不需要传地址过去，一级指针
	//如果哨兵位发生改变，就传二级指针
	assert(phead);
	LTNode* newnode = BuyListNode(x);
	//phead phead->prev newnode
	newnode->prev = phead->prev;
	newnode->next = phead;
	phead->prev->next = newnode;
	phead->prev = newnode;
}

3.1.2头插

//头插
void LTPushFront(LTNode* phead, LTDatatype x)
{
	assert(phead);
	//phead phead->next newnode
	LTNode* newnode = BuyListNode(x);
	//先改变d1

	newnode->prev = phead;
	newnode->next = phead->next;

	phead->next->prev = newnode;
	phead->next = newnode;
}

3.1.3打印

//打印
void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	//不等于哨兵位就继续向下遍历
	while (pcur != phead)
	{
		printf("%d ->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

3.1.4尾删

首先需要判断链表是否为空：

//判断是否为空
bool LTEmpty(LTNode* phead)
{
	assert(phead);
	//判断哨兵位的下一个是不是指向它自己
	//如果指向它自己说明链表为空
	return phead->next == phead;
	//如果return返回的是真，传给下面函数的是真
}

//尾删
void LTPopBack(LTNode* phead)
{//传过来的是真，就是phead->next==phead,就说明已经遍历结束,给前面加！表示已经为空。
	assert(!LTEmpty(phead));
	//判断是否为空
	LTNode* del = phead->prev;
	//phead del->prev del
	del->prev->next = phead;
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

3.1.5头删

//头删
void LTPopFront(LTNode* phead)
{
//
	assert(!LTEmpty(phead));
	LTNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

3.1.6找到指定位置

//找到指定位置
LTNode* LTFind(LTNode* phead, LTDatatype x)
{
	//需要遍历
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

3.1.7在指定位置pos之后插入数据

//在指定位置pos之后插入数据
void LTInsert(LTNode* pos, LTDatatype x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;
	pos->next->prev = newnode;
	pos->next = newnode;
}

3.1.8删除指定位置的数据

//在指定位置pos删除数据
void LTErase(LTNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

3.1.9销毁链表

//销毁
void LTDesTroy(LTNode** pphead)
{
	LTNode* pcur = (*pphead)->next;
	while (pcur != *pphead)
	{
		//释放之前把pcur的下一个结点先保存起来
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(*pphead);
	*pphead = NULL;
}

#4.源代码

list.h

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

typedef int LTDatatype;

typedef struct ListNode {
	LTDatatype data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

//申请一个结点
LTNode* BuyListNode(LTDatatype x);
//初始化
LTNode* LTInit();//调用
//void LTinit(LTNode** pphead);

//销尽量也传一级，这是保持接口的一致性。
//销毁
//void LTDesTroy(LTNode**phead);//要将哨兵位也销毁掉，所以要传二级指针
void LTDesTroy(LTNode* phead);
//打印
void LTPrint(LTNode* phead);

//判断是否为空
bool LTEmpty(LTNode* phead);
//尾插
void LTPushBack(LTNode* phead, LTDatatype x);
//头插
void LTPushFront(LTNode* phead, LTDatatype x);


//尾删
void LTPopBack(LTNode* phead);
//头删
void LTPopFront(LTNode* phead);

//在指定位置pos之后插入数据
void LTInsert(LTNode* pos, LTDatatype x);

//在指定位置pos删除数据
void LTErase(LTNode* pos);

//找到指定位置
LTNode* LTFind(LTNode* phead, LTDatatype x);

list.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"list.h"

//初始化
LTNode* LTInit()
{
	//创建头结点
	//LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
	//phead->data = -1;
	//phead->next = phead->prev;//需要将头结点指向它自己，就成为了带头双向循环链表
	//phead->prev = phead;
	LTNode* phead = BuyListNode(-1);
	return phead;//通过返回的方式
}

//销毁
//void LTDesTroy(LTNode** pphead)
//{
//	LTNode* pcur = (*pphead)->next;
//	while (pcur != *pphead)
//	{
//		//释放之前把pcur的下一个结点先保存起来
//		LTNode* next = pcur->next;
//		free(pcur);
//		pcur = next;
//	}
//	free(*pphead);
//	*pphead = NULL;
//}
void LTDesTroy(LTNode* phead)
{
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		LTNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(phead);
	phead = NULL;
}
//我把我的博客链接给你，你给我写。
//void LTinit(LTNode** pphead)
//{
//	assert(pphead);
//	*pphead = (LTNode*)malloc(sizeof(LTNode));
//	(*pphead)->data = -1;
//	(*pphead)->next = (*pphead)->prev = *pphead;
//
//}

//创建一个新的结点
LTNode* BuyListNode(LTDatatype x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail!\n");
		exit(1);
	}
	node->data = x;
	node->next = node->prev = node;
	return node;
}

//打印
void LTPrint(LTNode* phead)
{
	LTNode* pcur = phead->next;
	//不等于哨兵位就继续向下遍历
	while (pcur != phead)
	{
		printf("%d ->", pcur->data);
		pcur = pcur->next;
	}
	printf("\n");
}

//判断是否为空
bool LTEmpty(LTNode* phead)
{
	assert(phead);
	//判断哨兵位的下一个是不是指向它自己
	//如果指向它自己说明链表为空
	return phead->next == phead;
}

//尾插
void LTPushBack(LTNode* phead, LTDatatype x)
{
	//为什么这里传的是一级指针？
	//pphead不会发生改变，哨兵位的地址不会改变。
	//不需要传地址过去，一级指针
	//如果哨兵位发生改变，就传二级指针
	assert(phead);
	LTNode* newnode = BuyListNode(x);
	//phead phead->prev newnode
	newnode->prev = phead->prev;
	newnode->next = phead;
	
	phead->prev->next = newnode;
	phead->prev = newnode;
}

//头插
void LTPushFront(LTNode* phead, LTDatatype x)
{
	assert(phead);
	//phead phead->next newnode
	LTNode* newnode = BuyListNode(x);
	//先改变d1

	newnode->prev = phead;
	newnode->next = phead->next;

	phead->next->prev = newnode;
	phead->next = newnode;
}

//尾删
void LTPopBack(LTNode* phead)
{//不用判断是否为空
	assert(!LTEmpty(phead));
	//判断是否为空
	LTNode* del = phead->prev;
	//phead del->prev del
	del->prev->next = phead;
	phead->prev = del->prev;
	free(del);
	del = NULL;
}

//头删
void LTPopFront(LTNode* phead)
{
	assert(!LTEmpty(phead));
	LTNode* del = phead->next;
	del->next->prev = phead;
	phead->next = del->next;
	free(del);
	del = NULL;
}

//在指定位置pos之后插入数据
void LTInsert(LTNode* pos, LTDatatype x)
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	newnode->next = pos->next;
	newnode->prev = pos;
	pos->next->prev = newnode;
	pos->next = newnode;
}

//找到指定位置
LTNode* LTFind(LTNode* phead, LTDatatype x)
{
	//需要遍历
	LTNode* pcur = phead->next;
	while (pcur != phead)
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

//在指定位置pos删除数据
void LTErase(LTNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 1

#include"list.h"

void test()
{
	LTNode* plist = LTInit();//创建一个双向带头循环链表。
	/*LTNode* plist = NULL;
	LTInit(&plist);*///传一级指针的地址，实参的改变会影响实参。
	//上面两种方式都可以。
	LTPushBack(plist, 1);
	LTPushBack(plist, 2);
	LTPushBack(plist, 3);
	LTPushBack(plist, 4);
	LTPushBack(plist, 5);
	LTPrint(plist);
	//LTPopFront(plist);
	//LTPrint(plist);
	//LTNode* find = LTFind(plist, 2);
	//if (find == NULL)
	//{
	//	printf("未找到！\n");
	//}
	//else {
	//	printf("找到了！\n");
	//}
	//LTInsert(find, 99);
	//LTPrint(plist);
	//LTErase(find);
	//LTPrint(plist);
	LTDesTroy(plist);
	plist = NULL;//传一级需要手动将plist置为空。
}
int main()
{
	test();
	return 0;
}