数据结构链表

Posted 小参宿

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了数据结构链表相关的知识，希望对你有一定的参考价值。

🚀write in front🚀
📜所属专栏：初阶数据结构
🛰️博客主页：睿睿的博客主页
🛰️代码仓库：🎉VS2022_C语言仓库
🎡您的点赞、关注、收藏、评论，是对我最大的激励和支持！！！
关注我，关注我，关注我，你们将会看到更多的优质内容！！


文章目录

线性表：

  线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
  线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的.
  线性表在物理上存储时，通常以数组(顺序表)和链式结构(链表)的形式存储。

顺序表：

  在前面的通讯录程序的书写中，我们使用了顺序表来存放每个人的信息。但是我们会发现，顺序表存在以下问题：

  1. 中间/头部的插入删除，时间复杂度为O(N)
  2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

链表

1 链表的概念及结构

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

注意：

  • 从上图看出，链式结构在逻辑上是连续的，但在物理上不一定连续

  • 现实中的结点一般是从堆上申请出来的

  • 从堆上申请的空间，是按照一定的策略来分配的，两次申请空间可能连续可能不连续。

2 链表的分类

  实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

  1. 单向或者双向
  2. 带头或者不带头
  3. 循环或者非循环

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：

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

3.链表的实现

无头+单向+非循环链表增删查改实现

typedef int SLTDateType;
typedef struct SListNode

SLTDateType data;
struct SListNode* next;
SListNode;

我们先来看看链表的结构：
用data来保存数据，用*next保存下一个链表的指针。

动态申请一个结点
SLTNode* BuySLTNode(SLTDataType x)

	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	
		perror("malloc fail");
		return NULL;
	

	newnode->data = x;
	newnode->next = NULL;

	return newnode;
单链表打印

  在这里我们可以看出我们是如何遍历链表的：通过寻找NULL来遍历。

void SLTPrint(SLTNode* phead)

	SLTNode* cur = phead;
	//while (cur->next != NULL)
	//while(cur != NULL)
	while (cur)
	
		printf("%d->", cur->data);
		cur = cur->next;
		//cur++;
	
	printf("NULL\\n");
单链表尾插

这段代码会出现两个问题：

  1. 这里有一个很致命的问题，就是断言问题。大家在以往的学习中会习惯性的以为出现指针就断言，但是实际上应该具体情况具体分析！
    我们的链表在没有建立之前都是不存在的，此时head指向NULL，但是如果断言的话就会无法建立链表。所以我们不应该对于head进行断言。

  2. 当传过来的指针为空时，我们要通过二级指针使head指向第一个链表的头节点，所以我们要穿head指针的地址！当然，head指针的地址不可能为空，所以我们要断言他！

void SLTPushBack(SLTNode** pphead, SLTDataType x)

	assert(pphead);

	SLTNode* newnode = BuySLTNode(x);

	if (*pphead == NULL)
	
		*pphead = newnode;
	
	else
	
		// 找尾
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		
			tail = tail->next;
		

		tail->next = newnode;
单链表的头插
void SLTPushFront(SLTNode** pphead, SLTDataType x)

	assert(pphead);

	SLTNode* newnode = BuySLTNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
单链表的尾删

对于删除链表，我们是一定要断言的，因为对于空我们是无法删除的！我们只需找到倒数第二个节点然后把其next置空即可。

void SLTPopBack(SLTNode** pphead)

	// 暴力检查
	assert(pphead);
	assert(*pphead);

	// 温柔的检查
	//if (*pphead == NULL)
	//	return;

	// 1、只有一个节点
	// 2、多个节点
	if ((*pphead)->next == NULL)
	
		free(*pphead);
		*pphead = NULL;
	
	else
	
		// 找尾
		//SLTNode* prev = NULL;
		//SLTNode* tail = *pphead;
		//while (tail->next != NULL)
		//
		//	prev = tail;
		//	tail = tail->next;
		//

		//free(tail);
		//tail = NULL;

		//prev->next = NULL;

		SLTNode* tail = *pphead;
		while (tail->next->next != NULL)
		
			tail = tail->next;
		

		free(tail->next);
		tail->next = NULL;
单链表头删
void SLTPopFront(SLTNode** pphead)

	// 暴力检查
	assert(pphead);
	assert(*pphead);

	// 温柔的检查
	//if (*pphead == NULL)
	//	return;

	SLTNode* first = *pphead;
	*pphead = first->next;
	free(first);
	first = NULL;
单链表查找
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)

	SLTNode* cur = phead;
	while (cur)
	
		if (cur->data == x)
		
			return cur;
		

		cur = cur->next;
	

	return NULL;
单链表在pos位置之后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x)

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

分析思考为什么不在pos位置之前插入？
我们先来看看前插的代码：

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)

	assert(pos);
	assert(pphead);

	if (pos == *pphead)
	
		SLTPushFront(pphead, x);
	
	else
	
		// 找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		
			prev = prev->next;
		

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

在单链表我们无法通过节点找到该节点的上一个节点。要在pos前面插入节点，需要从前向后遍历链表，时间复杂度会变高。所以我们一般都是后插。

单链表删除pos位置之后的值
void SLTEraseAfter(SLTNode* pos)

	assert(pos);
	assert(pos->next);

	//SLTNode* del = pos->next;
	//pos->next = pos->next->next;
	//free(del);
	//del = NULL;

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

分析思考为什么不删除pos位置？
同样的先看看代码：

void SLTErase(SLTNode** pphead, SLTNode* pos)

	assert(pphead);
	assert(pos);
	//assert(*pphead);

	if (*pphead == pos)
	
		SLTPopFront(pphead);
	
	else
	
		// 找到pos的前一个位置
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		
			prev = prev->next;
		

		prev->next = pos->next;
		free(pos);
		//pos = NULL;

我们还是要先通过遍历找到pos的前一个节点，所以时间复杂度也会增加。

总结：

  对于每一个问题的所有情况都应该考虑周全。比如在对链表进行操作时，链表为空的情况，链表不为空都是只有一个链表的等等情况如何处理，头指针在什么时候需要断言的思考。

  更新不易，辛苦各位小伙伴们动动小手，👍三连走一走💕💕 ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！

专栏订阅：
每日一题
c语言学习
算法
智力题
初阶数据结构
更新不易，辛苦各位小伙伴们动动小手，👍三连走一走💕💕 ~ ~ ~ 你们真的对我很重要！最后，本文仍有许多不足之处，欢迎各位认真读完文章的小伙伴们随时私信交流、批评指正！

数据结构（链表——双向链表的实现）

链表——双向链表的实现

链表的概念及结构

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

链表的分类

实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：

带头双向循环链表的介绍（重点）

双向链表的实现

模型


思路（独一份）

双链表的各种方法实现

创建结构体并创建结构体指针变量

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

注意：
我们并不知道要存储什么数据,以int为例. 之所以用 LTDataType是为了以后修改int类型或其他类型方便。

实现双向表初始化

LTNode* BuyListNode(LTDataType x)//写一个结点
{
	LTNode* new = (LTNode*)malloc(sizeof(LTNode));
	if (new == NULL)
	{
		perror("BuyListNode");
	}
	new->data = x;
	new->next = NULL;
	new->prev = NULL;
	return new;
}

LTNode* ListInit()//将双向表初始化
{
	LTNode* phead = BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

实现双向链表销毁

void ListDestroy(LTNode* phead)
{
	assert(phead);
	size_t i = ListSize(phead);
	while (i--)
	{
		ListPopBack(phead);
	}
	//free(phead);
	//phead = NULL;
}

ListDestroy(list);
	free(list);
	list = NULL;


实现双向链表打印

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

双向链表打印已经没什么可说的了，无非是遍历这里要注意的点是：双向链表实现的是双向带头循环链表，因此当循环指向头结点时循环结束。

实现双向链表在任意位置的前面进行插入

void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* p = pos->prev;
	LTNode* new = BuyListNode(x);
	p->next = new;
	new->prev = p;
	new->next = pos;
	pos->prev = new;
}


实现双向链表在任意位置进行删除


void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* p = pos->prev;
	LTNode* n = pos->next;
	free(pos);
	pos = NULL;
	p->next = n;
	n->prev = p;
}

实现双向链表的头删和尾删、头插和尾插

注意：双向链表的头删和尾删、头插和尾插的实现时，要注意pos的位置

void ListPopBack(LTNode* phead)
{
	assert(phead);
	ListErase(phead->prev);
}
void ListPopFront(LTNode* phead)
{
	assert(phead);
	ListErase(phead->next);
}
void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead, x);
}

void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead->next, x);
}

实现双向链表查找

经历过上方的增删的实现这个查的实现就相对简单，只需遍历（但注意指针到头结点时停止循环）

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

实现双向链表的判空

bool ListEmpty(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	if (cur == phead)
	{
		return true;
	}
	else
	{
		return false;
	}
}

实现求双向链表的元素数量

这个是实现方法与双向链表打印相似，都是遍历（但注意指针到头结点时停止循环）

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

原码

List.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include <stdbool.h>
typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}LTNode;
void ListPrint(LTNode* phead);
LTNode* BuyListNode(LTDataType x);
//void ListInit(LTNode** pphead);
LTNode* ListInit();
void ListDestroy(LTNode* phead);

bool ListEmpty(LTNode* phead);
size_t ListSize(LTNode* phead);


void ListPushBack(LTNode* phead, LTDataType x);
void ListPushFront(LTNode* phead, LTDataType x);

void ListPopBack(LTNode* phead);
void ListPopFront(LTNode* phead);

LTNode* ListFind(LTNode* phead, LTDataType x);


void ListErase(LTNode* pos);

void ListInsert(LTNode* pos, LTDataType x);

List.c

#include"List.h"
void ListPrint(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\\n");
}


LTNode* BuyListNode(LTDataType x)
{
	LTNode* new = (LTNode*)malloc(sizeof(LTNode));
	if (new == NULL)
	{
		perror("BuyListNode");
	}
	new->data = x;
	new->next = NULL;
	new->prev = NULL;
	return new;
}


LTNode* ListInit()
{
	LTNode* phead = BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;
	return phead;
}


bool ListEmpty(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;
	if (cur == phead)
	{
		return true;
	}
	else
	{
		return false;
	}
}


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


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




void ListInsert(LTNode* pos, LTDataType x)
{
	assert(pos);
	LTNode* p = pos->prev;
	LTNode* new = BuyListNode(x);
	p->next = new;
	new->prev = p;
	new->next = pos;
	pos->prev = new;
}


void ListPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead, x);
}


void ListPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);
	ListInsert(phead->next, x);
}




void ListErase(LTNode* pos)
{
	assert(pos);
	LTNode* p = pos->prev;
	LTNode* n = pos->next;
	free(pos);
	pos = NULL;
	p->next = n;
	n->prev = p;
}


void ListPopBack(LTNode* phead)
{
	assert(phead);
	ListErase(phead->prev);
}
void ListPopFront(LTNode* phead)
{
	assert(phead);
	ListErase(phead->next);
}


void ListDestroy(LTNode* phead)
{
	assert(phead);
	size_t i = ListSize(phead);
	while (i--)
	{
		ListPopBack(phead);
	}
	//free(phead);
	//phead = NULL;
}

test.c

#include"List.h"
int main()
{
	LTNode* list= ListInit();
	ListPushBack(list, 1);
	ListPushBack(list, 2);
	ListPushBack(list, 3);
	ListPushBack(list, 4);
	ListPushBack(list, 5);
	ListPrint(list);
	ListPopBack(list);
	ListPrint(list);
	ListPopFront(list);
	ListPrint(list);
	ListDestroy(list);
	free(list);
	list = NULL;
	//ListPrint(list);
	return 0;
}

运行结果

终于~结束了

以上是关于数据结构链表的主要内容，如果未能解决你的问题，请参考以下文章

java 数据结构常考的OJ 链表，重点！重点！！！

用Java语言实现单向链表

Java数据结构之链表

『数据结构与算法』链表（单链表双链表环形链表）：原理与Java实现

Java数据结构—环形链表

数据结构 ---[链表 ] [使用链表实现栈 以及 队列 (Java代码实现)]