数据结构与算法 | 单链表 & 双向链表

Magic--Y

已于 2022-08-09 23:29:52 修改

阅读量120

点赞数

分类专栏：数据结构与算法文章标签：链表数据结构

于 2022-07-31 18:10:41 首次发布

本文链接：https://blog.csdn.net/ygy555/article/details/126077039

版权

数据结构与算法专栏收录该内容

6 篇文章 0 订阅

订阅专栏

链表的概念

链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的
链表中的元素可以处在任意位置，各个元素之间通过指针链接
由于链表并不连续，所以不用担心容量问题，只需创建一个新的节点，通过指针链接即可
这次实现的是单链表，结构简单，一般不会单独用来存数据

单链表接口的实现

🧨使用的平台是VS2019
🧨pro.c（主函数以及测试程序）
🧨SList.c（单链表各个功能函数的实现）
🧨SList.h（单链表函数的声明，头文件的引用）

函数的声明

SList.h

#pragma once

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

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

SLTNode* BuySLTNode(SLTDataType x);//创建节点
void SListPrint(SLTNode* phead);//单链表打印
void SListDestroy(SLTNode** phead);//单链表销毁
void SListPushFront(SLTNode** pphead, SLTDataType x);//头部插入
void SListPushBack(SLTNode** pphead, SLTDataType x);//尾部插入
void SListPopFront(SLTNode** phead);//头部删除
void SListPopBack(SLTNode** phead);//尾部删除


SLTNode* SListFind(SLTNode* phead, SLTDataType x);//查找

//在pos之前插入
void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

void SListInsertAfter(SLTNode* pos, SLTDataType x);//在pos之后插


//删除pos位置
//void SListErase(SLTNode** pphead, SLTNode* pos);

SList.c

打印单链表

void SListPrint(SLTNode* phead)
{ 
	SLTNode* cur = phead;
	while (cur != NULL)//cur是个结构体指针
	{
		printf("%d->", cur->data);
		cur = cur->next;//cur->next下一个节点的地址
	}
	printf("NULL\n");
}

1.在主函数中定义 SLTNode* plist = NULL; ，结构体类型的变量plist
2.由于在后续函数中可能需要遍历链表，所以链表头不能动，把值赋给临时变量cur，利用cur打印结构体成员数据
3.由于cur->next中存的是下一个节点的地址，所以cur=cur->next，寻找下一个节点的地址

动态申请一个新的节点

SLTNode* BuySLTNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));

	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;

	return newnode;

}

1.x就是所要插入新的节点的数据
2.利用malloc开辟一个 SLTNode* 的空间，空间里有个数据域和指针域，并判断是否为空
3.将x赋给新节点的data，新节点的next置为空，并且返回新节点的地址

头部插入一个节点

void SListPushFront(SLTNode** pphead, SLTDataType x)//头部插入
{
	assert(pphead);

	SLTNode* newnode = BuySLTNode(x);

	newnode->next = *pphead;
	*pphead = newnode;
}

1.将主函数中plist的地址传进来，对*(pphead)就是plist，通过操作*(pphead)实现对plist的改变，传地址的原因是因为要改plist的指向，如果只传进来 SLTNode类型的变量，无法起到修改作用，只有传地址，再解引用才能真正的改变主函数中的值，传任何形式的变量都无法修改
2.传二级指针的原因是要改变plist指向的位置，因为其类型是 SLTNode，如果函数参数也是此类型，改变的只是形参，形参只是实参的一份临时拷贝，形参的改变不会影响到实参，所以在主函数传的是&plist，由于plist的类型是 SLTNode*，所以函数的参数的类型是 SLTNode**
3.由于pplead存的是plist的地址，肯定不为空，所以进行assert
4.每次插入之前创建一个新的节点

尾部插入一个节点

void SListPushBack(SLTNode** pphead, SLTDataType x)//尾部插入
{
	assert(pphead);//pphead存的是plist的地址，不会是空

	SLTNode* newnode = BuySLTNode(x);

	if (*pphead == NULL)
	{
		*pphead = newnode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}

}

1.尾部插入也是先创建一个新的节点，但是分两种情况
2.第一种是本来没有节点，直接尾插，将newnode的地址赋给*pphead
3.第二种是利用tail遍历所有节点的next，直到找到NULL，再将新节点的地址赋给tail->next

头部删除节点

void SListPopFront(SLTNode** pphead)//头部删除
{
	assert(pphead);

	if (*pphead == NULL)
	{
		return;
	}

	SLTNode* del = *pphead;
	*pphead = (*pphead)->next;
	free(del);
	del = NULL;
}

1.先判断是否有节点，没有则不进行删除操作
2.如果有节点，先将要删除节点的地址保存下来，将下一个节点的地址赋值给*(pphead)
3.最后将要删除的节点的地址释放

尾部删除节点

void SListPopBack(SLTNode** pphead)//尾部删除
{
	assert(pphead);
	assert(*pphead != NULL);//没有

	if ((*pphead)->next == NULL)//只有一个
	{
		free(*pphead);
		*pphead = NULL;
	}

	SLTNode* prev = NULL;//多个
	SLTNode* tail = *pphead;

	while (tail->next != NULL)
	{
		prev = tail;
		tail = tail->next;
	}

	prev->next = NULL;
	free(tail);
	tail = NULL;

}

1.没有节点时，直接断言assert
2.只有一个节点时，直接将其释放
3.多个节点时：关键是需要找到前一个节点，使用prev找要删除的前一个几点，利用tail遍历所有的节点，直到找到NULL，然后将prev->next置为空，释放掉要删除的节点

销毁所有节点

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

	SLTNode* cur = *pphead;

	while (cur != NULL)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}

	*pphead = NULL;
}

1.利用cur遍历所有节点，如果不为空，保存下一个节点地址后，释放当前节点，最后将第一个节点释放

查找节点

SLTNode* SListFind(SLTNode* phead, SLTDataType x)//查找
{
	SLTNode* cur = phead;

	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}

	return NULL;
	//while (cur->data != x)
	//{
	//	cur = cur->next;
	//}

	//return 
}

1.利用cur遍历所有节点，直到找到与该节点存储的数据，返回该节点的地址，如果没有找到，返回空指针

在pos之前插入数据

void SListInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)//在pos之前插入 
{
	assert(pphead);
	assert(pos);

	if (pos == *pphead)
	{
		SListPushFront(pphead, x);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;

			assert(prev);
		}

		SLTNode* newnode = BuySLTNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}

}

1.如果在第一个节点插入，就是头插，调用相关函数即可
2.其他情况，主要目标是找到前一个节点，利用prev->next，找到下一个节点，assert是为了防止prev为空，找到最后都没有，说明传的pos有误
3.创建一个新的节点，再赋值

在pos之后插入数据

void SListInsertAfter(SLTNode* pos, SLTDataType x)//在pos之后插
{
	assert(pos);

	SLTNode* newnode = BuySLTNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}

1.在pos之后插，先创建一个新的节点，将pos下一个节点的地址给newnode->next，将newnode的地址赋给pos->next

删除pos位置的值

void SListErase(SLTNode** pphead, SLTNode* pos)//删除pos位置的值
{
	assert(pphead);
	assert(*pphead);

	if (*pphead == pos)
	{
		SListPopFront(pphead);
	}
	else
	{
		SLTNode* cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
			assert(cur);//检查pos是否为链表中的节点
		}
		cur->next = pos->next;
		free(pos);
	}
}

1.如果plist为空，没有节点，不能删除
2.如果只有一个节点，就是头删，调用函数
3.如果有多个节点，关键还是找到前一个节点，将前一个节点的cur->next置NULL，释放掉pos

删除pos位置之后的值

void SListEraseAfter(SLTNode* pos)//删除pos之后的值
{
	assert(pos);

	if (pos->next == NULL)
	{
		return;
	}
	else
	{
		SLTNode* next = pos->next;
		pos->next = next->next;
		free(next);
	}

}

1.如果pos->next是NULL说明是最后一个节点，或仅此一个节点，不能删除
2.若不是NULL，主要是找到pos后第二个位置的节点，即pos->next->next，将该地址赋给pos->next，最后释放掉next

链表优点和缺点

优点：非常适合头插头删，时间复杂度为O(1)
缺点：如果我们想要删除或插入头以外的位置时，必须要找到该点的前一个节点，时间复杂度为O(N)

双向链表

1.无论是next还是prev，其指向的都是某个节点的地址（该节点的地址）
2.带哨兵头的双向循环链表，结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表

双向链表接口的实现

函数的声明

#pragma once

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

typedef int LTDataType;

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


//void ListInit(LTNode** pphead);
void ListPrint(LTNode* phead);
void ListDestroy(LTNode* phead);

LTNode* ListInit();
void ListPushBack(LTNode* phead, LTDataType x);
void ListPushFront(LTNode* phead, LTDataType x);
void ListPopBack(LTNode* phead);
void ListPopFront(LTNode* phead);
bool ListEmpty(LTNode* phead);
size_t ListSize(LTNode* phead);
LTNode* ListFind(LTNode* phead, LTDataType x);

//在pos之前插入
void ListInsert(LTNode* pos, LTDataType x);
//删除pos位置
void ListErase(LTNode* pos);

初始化链表

LTNode* ListInit()//初始化
{
	LTNode* guard = (LTNode*)malloc(sizeof(LTNode));//哨兵位头

	if (guard == NULL)
	{
		perror("guard");
		exit(-1);
	}
	guard->next = guard;
	guard->prev = guard;

	return guard;
}//phead、plist都是指向哨兵位的头节点

打印链表

void ListPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	printf("guardHead<=>");
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

创建节点

LTNode* BuyListNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));//哨兵位头

	if (node == NULL)
	{
		perror("node");
		exit(-1);
	}

	node->next = NULL;
	node->prev = NULL;
	node->data = x;
	return node;
}

尾插

void ListPushBack(LTNode* phead, LTDataType x)//尾插
{
	assert(phead);

	//LTNode* newnode = BuyListNode(x);
	//LTNode* tail = phead->prev;

	//tail->next = newnode;
	//newnode->prev = tail;
	//newnode->next = phead;
	//phead->prev = newnode;
	ListInsert(phead, x);
}

头插

void ListPushFront(LTNode* phead, LTDataType x)//头插
{
	assert(phead);

	//LTNode* newnode = BuyListNode(x);
	//newnode->next = phead->next;
	//phead->next->prev = newnode;

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

	ListInsert(phead->next, x);
}

尾删

void ListPopBack(LTNode* phead)//尾删
{
	assert(phead);
	assert(!ListEmpty(phead));

	//LTNode* tail = phead->prev;
	//LTNode* prev = tail->prev;

	//prev->next = phead;
	//phead->prev = prev;

	//free(tail);

	ListErase(phead->prev);
}

头删

void ListPopFront(LTNode* phead)//头删
{
	assert(phead);

	//LTNode* first = phead->next;
	//LTNode* second = first->next;

	//phead->next = second;
	//second->prev = phead;

	//free(first);

	ListErase(phead->next);
}

查找

LTNode* ListFind(LTNode* phead, LTDataType x)//查找
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

在pos之前插入

void ListInsert(LTNode* pos, LTDataType x)//在pos之前插入x
{
	assert(pos);
	LTNode* newnode = BuyListNode(x);
	LTNode* prev = pos->prev;

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

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

删除节点

void ListErase(LTNode* pos)
{
	assert(pos);

	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

	prev->next = next;
	next->prev = prev;

	free(pos);
}

销毁节点

void ListDestroy(LTNode* phead)
{
	assert(phead);

	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

判断是否为空

bool ListEmpty(LTNode* phead)
{
	assert(phead);

	return phead->next == phead;
}

判断节点数量

size_t ListSize(LTNode* phead)
{
	assert(phead);

	size_t n = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		n++;
		cur = cur->next;
	}
	return n;
}