【数据结构与算法】线性表之链表（linked list）

已于 2024-01-25 12:09:24 修改
阅读量459 收藏 12
点赞数 11
分类专栏： Data Structure and Algorithm C 文章标签： 数据结构 c语言 链表 leetcode
于 2024-01-13 12:39:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52602233/article/details/135568147
版权
本文详细介绍了单向无头非循环链表和双向带头循环链表的结构、操作方法，以及它们与顺序表的对比，重点展示了在实际应用中的优势和场景。
摘要由CSDN通过智能技术生成

文章目录

往期相关文章推荐：线性表之顺序表

1. 概念

  链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
在这里插入图片描述
链表在逻辑上是连续的，物理上则不一定连续（因为每个节点内存由操作系统分配），节点一般从堆内存申请，堆内存空间是按照一定策略分配的，两次申请的空间可能连续，也可能不连续。

2. 链表分类

以下不同情况下组合起来有8种链表结构：

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

不过实际中最常用还是两种结构：

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

3. 链表与顺序表对比

这里的对比是双向带头循环链表与顺序表对比，这更有意义。这是因为单向不带头非循环链表在实际使用时，并不会单独用来存储数据，所以单向不带头非循环链表对比顺序表的优缺点是意义不大的。

不同角度顺序表链表
存储结构逻辑、物理连续逻辑连续，物理不一定连续
随机访问支持，效率高不支持，效率较低
插入或删除效率低效率高
容量容量不足时需要扩容不需要扩容
缓存利用率高低
应用场景高效存储和频繁访问频繁插入和删除

4. 单向无头非循环链表

4.1 SingleLinkedList.h

#pragma once

/* 单向、无头（无哨兵位）、不循环链表 */

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


/* -------------
 * 链表结构说明。
 * -------------
 * @datatype：值的数据类型；
 * @ListNode：节点；
*/
typedef int datatype; 

typedef struct ListNode { 
	datatype val;
	struct ListNode* next;
} ListNode;

// 创建节点
ListNode* CreateNode(datatype val);


/* -----------------------
 * 增操作：向链表添加节点。
 * -----------------------
 * @PushFront：头插；
 * @PushBack：尾插。
 * @InsertBefore：在指定节点之前添加新节点，需要配合Find函数使用；
 * @InsertAfter：在指定节点之后添加新节点，需要配合Find函数使用。
*/
void PushFront(ListNode** pphead, datatype val);
void PushBack(ListNode** pphead, datatype val);
void InsertBefore(ListNode** pphead, ListNode* pos, datatype val);
void InsertAfter(ListNode** pphead, ListNode* pos, datatype val);


/* ---------------------
 * 删操作：删除链表节点。
 * ---------------------
 * @Clear：清空链表中所有节点；
 * @PopFront：头删；
 * @PopBack：尾删；
 * @Erase：删除一个节点，需要配合Find函数使用；
 * @EraseBefore：删除指定前一个节点；
 * EraseAfter：删除指定后一个节点；
 * @Remove：根据值指定删除节点。
*/
void Clear(ListNode** pphead);
void PopFront(ListNode** pphead);
void PopBack(ListNode** pphead);
void Erase(ListNode** pphead, ListNode* pos);
void EraseBefore(ListNode** pphead, ListNode* pos);
void EraseAfter(ListNode** pphead, ListNode* pos);
void Remove(ListNode** pphead, datatype val);


/* ---------------------
 * 查操作：查询链表节点。
 * ---------------------
 * @PrintList：打印所有节点值；
 * @Find：根据值查询返回一个节点；
*/
void PrintList(ListNode** pphead);
ListNode* Find(ListNode** pphead, datatype val);

4.2 SingleLinkedList.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "SingleLinkedList1.h"


// 创建并返回一个节点
ListNode* CreateNode(datatype val) {
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	if (node == NULL) {
		perror("CreateNode(val) malloc failed.");
		return NULL;
	}
	node->val = val;
	node->next = NULL;
	return node;
}


// 1.头插
void PushFront(ListNode** pphead, datatype val) {
	assert(pphead);
	ListNode* newNode = CreateNode(val);
	newNode->next = *pphead;
	*pphead = newNode;
 }

// 2.尾插
void PushBack(ListNode** pphead, datatype val) {
	assert(pphead);
	ListNode* newNode = CreateNode(val);
	if (*pphead == NULL) {
		*pphead = newNode;
	}
	else { // 找尾
		ListNode* tail = *pphead;
		while (tail->next) {
			tail = tail->next;
		}
		tail->next = newNode;
		tail = newNode;
	}
	
}

// 3.在指定节点前插入新节点
void InsertBefore(ListNode** pphead, ListNode* pos, datatype val) {
	assert(pphead);
	if(pos == NULL) { // 1.直接尾插
		PushBack(pphead, val);
	} 
	else if (*pphead == pos || *pphead == NULL) { // 2.直接头插
		PushFront(pphead, val);
	} 
	else { // 3.不用考虑链表为NULL情况，这时pos也为NULL
		// 找pos的前一个节点
		ListNode* prev = *pphead;
		while (prev->next != pos) {
			prev = prev->next;
		}
		ListNode* newNode = CreateNode(val);
		newNode->next = prev->next;
		prev->next = newNode;
	}
}

// 4.在指定节点后插入新节点
void InsertAfter(ListNode** pphead, ListNode* pos, datatype val) {
	assert(pphead);
	/* 关于assert(pos)：
	 * 1.NULL后面不能插入节点；
	 * 2.链表为NULL，pos也一定是NULL；
	 * 3.pos为NULL，链表不一定为NULL。
	 */ assert(pos);
	ListNode* cur = *pphead;
	while (cur != pos) {
		cur = cur->next;
	}
	ListNode* newNode = CreateNode(val);
	newNode->next = cur->next;
	cur->next = newNode;
}


// 1.清空链表
void Clear(ListNode** pphead) {
	assert(pphead);
	ListNode* cur = *pphead;
	ListNode* del = NULL;
	while (cur) {
		del = cur;
		cur = cur->next;
		free(del);
	}
	*pphead = NULL;
}

// 2.头删
void PopFront(ListNode** pphead) {
	assert(pphead && *pphead);
	ListNode* del = *pphead;
	*pphead = (*pphead)->next;
	free(del);
}

// 3.尾删
void PopBack(ListNode** pphead) {
	assert(pphead && *pphead);
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
	}
	else {
		ListNode* cur = *pphead;
		while (cur->next->next) {
			cur = cur->next;
		}
		free(cur->next);
		cur->next = NULL;
	}
}

// 指定删除
void Erase(ListNode** pphead, ListNode* pos) {
	assert(pphead);
	/* 关于assert(pos)：
	 * 1.不能删除NULL指；
	 * 2.链表为NULL，pos也一定是NULL；
	 * 3.pos为NULL，链表不一定为NULL。
	 */ assert(pos);
	if (pos == *pphead) {
		PopFront(pphead);
	}
	else {
		ListNode* prev = *pphead;
		while (prev->next != pos) {
			prev = prev->next;
		}
		ListNode* del = prev->next;
		prev->next = prev->next->next;
		free(del);
	}
}

// 删除指定节点前一个
void EraseBefore(ListNode** pphead, ListNode* pos) {
	assert(pphead && *pphead);
	if (*pphead != pos) {
		if ((*pphead)->next == pos) {
			free(*pphead);
			*pphead = pos;
		}
		else {
			ListNode* prev = *pphead;
			while (prev && prev->next && prev->next->next != pos) {
				prev = prev->next;
			}
			free(prev->next);
			prev->next = pos;
		}
	}
}

// 删除指定节点后一个
void EraseAfter(ListNode** pphead, ListNode* pos) {
	assert(pphead && *pphead && pos);
	if (pos->next) {
		ListNode* del = pos->next;
		pos->next = pos->next->next;
		free(del);
	}
}

// 根据值指定删除
void Remove(ListNode** pphead, datatype val) {
	assert(pphead && *pphead);
	ListNode* cur = *pphead;
	ListNode* next = NULL;
	while (cur) {
		next = cur->next;
		if (cur->val == val) {
			Erase(pphead, cur);
		}
		cur = next;
	}
}


// 打印链表
void PrintList(ListNode** pphead) {
	for (ListNode* cur = *pphead; cur != NULL; cur = cur->next) {
		printf("%d->", cur->val);
	}
	printf("NULL\n");
}

// 查询并返回节点
ListNode* Find(ListNode** pphead, datatype val) {
	ListNode* cur = *pphead;
	while (cur) {
		if (cur->val == val) {
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

5.双向带头循环链表

5.1 DoubleLinkedList.h

#pragma once

/* 双向、带头（哨兵位）、循环链表 */

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

typedef int datatype;

typedef struct ListNode {
	datatype val;
	struct ListNode* prev;
	struct ListNode* next;
} ListNode;

// 初始化链表
ListNode* InitList();
// 创建节点
ListNode* CreateNode(datatype val);

// 打印节点
void PrintList(ListNode* phead);
// 查找节点
ListNode* Find(ListNode* phead, datatype val);

// 头插
void PushFront(ListNode* phead, datatype val);
// 头删
void PopFront(ListNode* phead);

// 尾插
void PushBack(ListNode* phead, datatype val);
// 尾删
void PopBack(ListNode* phead);

// 在pos节点前插入一个新节点
void Insert(ListNode* pos, datatype val);
// 删除pos节点
void Erase(ListNode* pos);
// 清空链表
void Clear(ListNode* phead);

5.1 DoubleLinkedList.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "DoubleLinkedList.h"

// 初始化链表
ListNode* InitList() {
	ListNode* phead = CreateNode(-1);
	phead->prev = phead;
	phead->next = phead;
	return phead;
}
// 创建节点
ListNode* CreateNode(datatype val) {
	ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
	if (newNode == NULL) {
		perror("CreateNode(val) malloc failed.");
		return NULL;
	}
	newNode->val = val;
	newNode->prev = NULL;
	newNode->next = NULL;
	return newNode;
}

// 打印节点
void PrintList(ListNode* phead) {
	if (phead) {
		printf("head<->");
		for (ListNode* cur = phead->next; cur != phead; cur = cur->next) {
			printf("%d<->", cur->val);
		}
		printf("head\n");
	}
	else {
		printf("null\n");
	}
}
// 查找节点
ListNode* Find(ListNode* phead, datatype val) {
	for (ListNode* cur = phead->next; cur != phead; cur = cur->next) {
		if (cur->val == val) return cur;
	}
	return NULL;
}

// 头插
void PushFront(ListNode* phead, datatype val) {
	//ListNode* newNode = CreateNode(val);
	//newNode->next = phead->next;
	//phead->next->prev = newNode;
	//phead->next = newNode;
	//newNode->prev = phead;
	Insert(phead->next, val);
}
// 头删
void PopFront(ListNode* phead) {
	if (phead->next != phead) {
		ListNode* first = phead->next;
		phead->next = first->next;
		first->next->prev = phead;
		free(first);
	}
}

// 尾插
void PushBack(ListNode* phead, datatype val) {
	//ListNode* newNode = CreateNode(val);
	//phead->prev->next = newNode;
	//newNode->prev = phead->prev;
	//newNode->next = phead;
	//phead->prev = newNode;
	Insert(phead, val);
}
// 尾删
void PopBack(ListNode* phead) {
	if (phead->next != phead) {
		ListNode* tail = phead->prev;
		phead->prev = tail->prev;
		tail->prev->next = phead;
		free(tail);
	}
}

// 在pos节点前插入一个新节点
void Insert(ListNode* pos, datatype val) {
	assert(pos);
	ListNode* newNode = CreateNode(val);
	newNode->next = pos;
	newNode->prev = pos->prev;
	pos->prev = newNode;
	newNode->prev->next = newNode;
}
// 删除pos节点
void Erase(ListNode* pos) {
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
}
// 清空链表
void Clear(ListNode* phead) {
	ListNode* cur = phead->next;
	while (cur != phead) {
		ListNode* del = cur;
		cur = cur->next;
		free(del);
	}
	free(phead);
}
念来过倒字名qwq
关注
专栏目录
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法之线性表(链表)
积一时之步，臻千里之遥程
02-15 180
学习笔记 文章目录1 单向链表2 单项循环链表3 双向链表 为什么需要链表 顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活。 链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。 更详细的总结 引用图片：https://blog.csdn.net/wq6ylg08/article/details/103426582 引用图片：https://blog.csdn.net/wq6ylg08/article/details/103.
数据结构——链表（Linked List）
热门推荐
jishuxhengjiu的博客
08-31 1万+
使用单向环形链表解决Josephu问题，用不带头结点的单向循环链表先构成一个有n个节点的链表，然后由k节点起从1开始计数，直到第m时，对应节点删除，然后从被删除的下一个节点开始从1开始计数，直到最后一个节点被删除结束算法。2.temp.next = temp.next.next，也就是说需要删除节点的前一个节点本来指向的是删除节点，然后我们使其指向删除节点的下一个节点，直接跳过删除节点，这样该节点也就相当于被删除了。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3。1.单链表是以节点的方式来存储的。.
《数据结构、算法与应用C++语言描述》线性表-链表描述
Jasmine-Lily的博客
12-18 1001
《数据结构、算法与应用C++语言描述》线性表-链表描述
数据结构与算法-链表（线性表的链表表示和实现）
Oligizzz
02-17 1588
本文部分内容摘自极客时间《数据结构与算法之美》和网络，仅供笔者学习和复习用。 单链表的定义和表示 什么是链表 1.和数组一样，链表也是一种线性表。 2.从内存结构来看，链表的内存结构是不连续的内存空间（也可以是连续的），是将一组零散的内存块串联起来，从而进行数据存储的数据结构。 3.链表中的每一个内存块被称为节点Node。节点除了存储数据外，还需记录链上下一个节点的地址，即后继指针nex...
大数据最新数据结构与算法——线性表（链表篇）_线性链表
2401_84184638的博客
05-04 838
TnO1T(n)=O(1)T(n)=O(1)，而程序运行所耗费的时间都在找到要插入的元素位置的前一个位置，所以综合考究:**📌平均时间复杂为TnOn。
数据结构与算法-Part3——线性表
leikang111的博客
04-03 1426
线性表
2024年数据结构与算法——线性表（链表篇）_线性链表，我的阿里春招之路分享
2301_82243558的博客
05-05 612
以上就是线性表中链表的相关知识整理，配合代码是实例讲解链表的基本操作，相对于顺序表来说，链表的分类较为多一些，且操作也较为复杂一些，但只要认真看完本篇文章，你会对链表有更为详细的认知和理解，文章内容很多，知识点也很全面，一如既往希望我的文章能给各位小伙伴们带来帮助，数据结构与算法专栏也在持续更细中！！！！🎨😀别忘了给我关注~~😀网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化资料的朋友，可以戳这里获取。
数据结构与算法（java）：线性表（链表-双向链表）
lalala_dxf的博客
02-17 488
线性表 双向链表
C#，单向链表（Simply Linked List）快速排序（Quick Sort）算法与源代码
03-24
各种数据结构、算法及实用的C#源代码.C#，单向链表（Simply Linked List）快速排序（Quick Sort）算法与源代码.单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部...
数据结构与算法 | 线性表 —— 链表
王维
12-29 195
原文链接：https://wangwei.one/posts/java-data-structures-and-algorithms-linkedlist.html 链表 定义 逻辑结构上一个挨一个的数据，在实际存储时，并没有像顺序表那样也相互紧挨着。恰恰相反，数据随机分布在内存中的各个位置，这种存储结构称为线性表的链式存储。 由于分散存储，为了能够体现出数据元素之间的逻辑关系，每个数据元...
数据结构编程实践20讲(Python版)—06二叉搜索树
AnFany
10-08 1142
数据结构编程实践20讲(Python版)—06二叉搜索树
每日学习一个数据结构-树
wendao76的专栏
10-03 1157
树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。在非空树中，有且仅有一个特定的节点被称为根（root），其余节点可分为m（m>0）个互不相交的有限集T1, T2, …, Tm，其中每一个集合本身又是一棵树，并且被称为根的子树（Subtree）。访问时机：三种遍历方式的主要区别在于访问根节点的时机不同。在前序遍历中，根节点在左、右子节点之前被访问；在中序遍历中，根节点在左、右子节点之间被访问；在后序遍历中，根节点在左、右子节点之后被访问。应用场景。
C语言基本概念
ROBIN__dyc的博客
10-03 784
标识符：编写程序时，需要对变量、函数、宏和其他实体进行命名，这些名字称为标识符。函数是C语言中构建程序的构建块，事实上，C语言是函数的集合。函数分为两大类，一类是程序员编写的函数，一类是作为C语言实现的一部分提供的函数，即库函数。所有指令都是以字符#开始的，默认只占一行，每条指令的结尾没有分号或其他特殊标记。int 型变量取值的范围是有限的，通常为-2³¹～2³¹-1，但某些计算机上最大整数可能只有32767。语句是程序运行时执行的命令，C语言规定每条语句都要以分号结尾（复合语句是例外）。
C 共用体
最新发布
lly202406的博客
10-10 338
在C语言中，共用体使用union关键字定义。共用体的所有成员共享同一块内存空间，这意味着在任何时刻，共用体只能存储其中一个成员的数据。// ...其中，union_name是共用体的名称，type是成员的数据类型，member1member2等是共用体的成员。
【LeetCode】每日一题 2024_10_5 完成旅途的最少时间（二分答案）
Locky136的博客
10-05 576
【LeetCode】每日一题 2024_10_5 完成旅途的最少时间（二分答案）
【LeetCode】每日一题 2024_10_6 加油站（贪心）
Locky136的博客
10-06 551
【LeetCode】每日一题 2024_10_6 加油站（贪心）
头歌数据结构与算法，线性表答案
09-04
它通常用于列表数据结构，如单链表或双链表的头部。头指针数据结构的特点是有一个指向第一个元素的指针，而不是直接从数组的第一个元素开始。这使得插入和删除操作更为高效，因为可以直接对头节点进行修改而无需移动...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

念来过倒字名qwq

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值