线性表重点之链表

已于 2022-07-23 18:23:45 修改
阅读量247 收藏 4
点赞数 7
分类专栏： 数据结构专栏 文章标签： 链表 数据结构
于 2022-07-23 18:22:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LibraRhy/article/details/125950039
版权

目录

1、链表的表示和实现

引言 继顺序表的问题：

1.1链表的概念及结构

1.2无头  不循环 单向 链表表篇

1.3带头 循环 双向链表篇

2.顺序表和链表的区别和联系

顺序表：

链表：

1、链表的表示和实现

引言 继顺序表的问题：

问题：

1. 中间/头部的插入删除，时间复杂度为O(N)

2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到

200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

解决以上问题 可引入链表

1.1链表的概念及结构

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

 链表是通过前一节点存着下一节点的地址，通过地址找到下一节点，从而达到逻辑上的连续。

实际中要实现的链表的结构非常多样，以下情况组合起来就有 8 种链表结构：
1. 单向、双向
2. 带头、不带头
3. 循环、非循环

最多可组合8种不同的链表

 

 

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

这两种中也包含了其余六种结构

结构最简单的无头不循环单向链表：

 结构最复杂的带头循环双向链表：

1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结 构

的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

2. 带头双向循环链表： 结构最复杂 ，一般用在单独存储数据。实际中使用的链表数据结构，都
是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带
来很多优势，实现反而简单了，后面我们代码实现了就知道了。

1.2无头  不循环 单向 链表表篇

无头 不循环 单向链表的实现

typedef int SLTDataType;
typedef struct SlistNode
{
	SLTDataType data;
	struct SlistNode* next;
 }SLTNode;
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode*  phead);
// 单链表尾插
void SListPushBack(SListNode**  pphead, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode**  pphead, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode**  pphead);
// 单链表头删
void SListPopFront(SListNode** pphead);
// 单链表查找 pheadSListNode* SListFind(SListNode* pphead, SLTDateType x);
// 单链表在pos位置之前插入x
void SListInsert(SListNode** pphead, SListNode* pos, SLTDateType x);
// 单链表删除pos位置的值
void SListErase(SListNode** pphead, SListNode* pos);

以下分别写出接口函数 

注意：单链表的插入和删除函数传参均需传二级指针

//尾插
void SlistPushBack(SLTNode**pphead, SLTDataType x)
{
	SLTNode*newNode = (SLTNode*)malloc(sizeof(SLTNode));
	newNode->data = x;
	newNode->next = NULL;
	if (*pphead == NULL)
	{
		*pphead = newNode;
	}
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newNode;
	}
	
}
//头插
void SlistPushFront(SLTNode** pphead, SLTDataType x)
{
	SLTNode*newNode = (SLTNode*)malloc(sizeof(SLTNode));
	newNode->next = *pphead;
	newNode->data = x;
	*pphead = newNode;
}
//尾删
void SlistPopBack(SLTNode** pphead)
{
	
	if (*pphead == NULL)
	{
		return;
	}
	else 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);
		prev->next = NULL;
	}
}
//头删
void SlistPophFront(SLTNode** pphead)
{
	
	if (*pphead == NULL)
	{
		return;
	}
	else
	{
		SLTNode*start = *pphead;
		*pphead = (*pphead)->next;
		free(start);
		start->next = NULL;
	}
}
//查找
SLTNode* SlistFind(SLTNode*phead, SLTDataType x)
{
	SLTNode*cur = phead;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
//任意pos位置的插入
void SlistInsert(SLTNode**pphead, SLTNode* pos, SLTDataType x)
{
	if (*pphead == pos)
	{
		SlistPushFront(pphead, 10);
	}
	else
	{
		SLTNode*newnode = (SLTNode*)malloc(sizeof(SLTNode));
		SLTNode*cur = *pphead;
		while (cur->next != pos)
		{
			cur = cur->next;
		}
		newnode->data = x;
		cur->next = newnode;
		newnode->next = pos;
	}
	
}
//任意pos位置的删除
void SlistErase(SLTNode**pphead, SLTNode* pos)
{
	SLTNode*cur = *pphead;
	while (cur->next != pos)
	{
		cur = cur->next;
	}
	cur->next = pos->next;
	free(pos);
	pos = NULL;
}
//打印
void SlistPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != 0)
	{
		printf("%d->",cur->data);
		cur = cur->next;
	}

}

1.3带头 循环 双向链表篇

//带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
 LTDataType data;
 struct ListNode* next;
 struct ListNode* prev; 
}ListNode;
// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* phead);
// 双向链表打印
void ListPrint(ListNode*  phead);
// 双向链表尾插
void ListPushBack(ListNode*  phead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode*  phead);
// 双向链表头插
void ListPushFront(ListNode*  phead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode*  phead);
// 双向链表查找
ListNode* ListFind(ListNode*  phead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

以下分别实现各个接口函数

注意：因为链表带头哨兵卫的头节点，函数传参时不需要改变外部plist，所以不需要传二级指针

//节点内存开辟
LSTNode* BuyListNode(LSTDataType x)
{
	LSTNode*newnode = (LSTNode*)malloc(sizeof(LSTNode));
	LSTDataType data= x;
	LSTNode*prev = NULL;
	LSTNode*next = NULL;
	return newnode;
}
//初始化链表
LSTNode* ListInit()
{
	LSTNode*phead = BuyListNode(1);  
	phead->next = phead;
	phead->prev = phead;
	return phead;
}
//打印
void ListPrint(LSTNode*phead)
{
	LSTNode*cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
//内存销毁
void ListDestory(LSTNode*phead)
{
	LSTNode*cur = phead->next;
	while (cur != phead)
	{
		LSTNode*next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	phead = NULL;
}
//尾插
void ListPushBack(LSTNode*phead, LSTDataType x)
{
	// ListInsert(phead, phead, x);  //也可以直接调用ListInsert接口函数实现

	LSTNode*newnode = BuyListNode(x);
	LSTNode*tail = phead->prev;	
	newnode->data = x;
	tail->next = newnode;
	newnode->prev = tail;
	phead->prev = newnode;
	newnode->next = phead;
	
}
//头插
void ListPushFront(LSTNode*phead, LSTDataType x)
{
	//ListInsert(phead, phead->next, x);  //也可直接调用ListInsert接口函数实现

	LSTNode*newnode = BuyListNode(x); 
	LSTNode*first = phead->next;
	newnode->data = x;
	phead->next = newnode;
	newnode->next = first;
	first->prev = newnode;
	newnode->prev = phead;
}
//尾删
void ListPopBack(LSTNode*phead)
{
	assert(phead);
	assert(phead->next != phead);
	//ListErase(phead, phead->prev);  //也可直接调用ListErase接口函数实现

	LSTNode*tail = phead->prev;
	tail->prev->next = phead;
	phead->prev = tail->prev;
	free(tail);
	tail = NULL;
	
}
//头删
void ListPopFront(LSTNode*phead)
{
	assert(phead);
	assert(phead->next != phead);
	//ListErase(phead,phead->next); //也可直接调用ListErase接口函数实现

	LSTNode*first = phead->next;
	LSTNode*second = first->next;
	phead->next = second;
	second->prev = phead;
	free(first);
	first = NULL;
}
//查找
LSTNode* ListNodeFind(LSTNode*phead, LSTDataType x)
{
	LSTNode*cur = phead->next;
	while(cur != phead)
	{
		if (cur->data == x)
		{
			
			//printf("找到了\n");
			return cur;
		}
		cur = cur->next;
	}
		
		//printf("未找到！\n");
		return 0;   //未找到
	
}
//任意pos位置插入节点
void ListInsert(LSTNode*phead,LSTNode*pos, LSTDataType x)
{
	LSTNode*newnode = BuyListNode(x);
	newnode->data = x;
	LSTNode*prev = pos->prev;
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;
}
//任意pos位置删除节点
void ListErase(LSTNode*phead, LSTNode*pos)
{
	LSTNode*prev = pos->prev;
	LSTNode*next = pos->next;
	prev->next =next;
	next->prev = prev;
	free(pos);
	pos = NULL;
}

2.顺序表和链表的区别和联系

顺序表：

优点：
空间连续、支持随机访问
缺点：
1. 中间或前面部分的插入删除时间复杂度 O(N)
2. 2. 增容的代价比较大。

链表：

缺点：
以节点为单位存储，不支持随机访问
优点：
1. 任意位置插入删除时间复杂度为 O(1)
2. 没有增容消耗，按需申请节点空间，不用了直接释放。
爱算法的喵酱
关注
  • 7
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
线性表的顺序和链式实现方式
10-21
数据结构中线性表的两种实现方式。 c语言实现，函数封装。
【误区修正】如何确定一个链表中有闭环，以及发生闭环的位置？
QixuanAIRobot的专栏
01-01 1111
利用两个指针p1,p2(每次分别增1和2)来进行判断 使用两个指针 ： slow和fast ， slow每次移动一位，fast每次移动两位，当发生以下条件之一时结束，时间复杂度为O(n)。 首先一个终止的条件是指针p2遇到NULL节点.这说明不存在闭环 另外一个条件式当两个指针相遇就终止,这说明有闭环 为什么有环的情况下二者一定会相遇呢？因为fast先进入环，在slow进入之后，如果把slo...
R语言 基本操作与基础知识
qq_39852142的博客
10-23 1314
1.赋值 x <- 0.5 2.产生一等差数列，from首相，to末项，by等差，项数length(length.out) seq(from = 1, to = 1, by = ((to - from)/(length.out - 1))
数据结构实验-链表及栈的应用-天津理工大学
05-04
1、复习线性表（顺序表、链表）、栈（顺序存储、链式存储）、队列（顺序 存储、链式存储）的特点和基本操作；充分了解实验内容，进行问题分析，复习 相关知识并完成算法设计，初步完成程序设计，为实验作好充分的...
重点考点概括
10-17
数据结构重点考点总结，第一章 概 论，第二章 线性表，第三章 栈和队列，第四章 串，第五章 多维数组，第六章 树，第七章 图，第八章 排序，第九章 查找
数据结构：线性链表的表示以及实现(C语言编写)
12-11
数据结构：线性链表的表示以及实现(C语言编写) 有完整的代码注释以及重点分析
c++语言线性表及应用课程设计报告 .doc
07-05
帮助学生熟练掌握线性表的基本操作在两种存储结构上的实现，其中以单链表的操作和应用为重点内容。 二． 问题描述 编制一个演示单链表的建立、打印、查找、插入、删除等操作的程序。 三． 需求分析 1. 创建单链表 2....
链表
R的博客
08-21 91
用链表存储输入的数字，要求存储的顺序与输入的顺序相反 1.记住分配空间啊！！！！ #include <stdio.h> #include <stdlib.h> typedef struct LNode { int data; LNode *next; }LNode; void main() { LNode *L = NULL; LNode *p = NUL...
数据结构之链表操作（单链表，单向循环链表，双向循环链表）查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等操作
qq_45698138的博客
05-16 1974
一、线性表 线性表结构的数据是依次排列（一对一） （1）顺序结构：数组，顺序栈，顺序队列（顺序表） （2）链式存储：链表，链式栈，链式队列（线性表） 二、链表 2.1、链表 ​ 链表是一种具体的数据结构 ​ 1、逻辑上：一对一的排列 ​ 2、存储上：非连续的 ​ 3、算法：查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等等 ​ 4、链表分类 ​ 单向链表，双向链表，单向循环链表，双向循环链表 ​ 5、链式存储特点 ​ 不需要一块连续
用R语言进行关联分析
helen1313的专栏
07-23 9220
主要参考《数据挖掘：R语言实战》（黄文，王正林编著）
R语言中实现表的链接-merge函数
lijinxiu123的博客
03-17 5737
R语言中实现表的链接 R中merge函数
R语言 | 关联规则
热门推荐
I think so I am
04-12 10万+
关联规则（AssociationRules）是无监督的机器学习方法，用于知识发现，而非预测。 关联规则的学习器（learner）无需事先对训练数据进行打标签，因为无监督学习没有训练这个步骤。缺点是很难对关联规则学习器进行模型评估，一般都可以通过肉眼观测结果是否合理。 关联规则主要用来发现Pattern，最经典的应用是购物篮分析，当然其他类似于购物篮交易数据的案例也可以应用关联规则进行模式发现。
数据结构——单链表
RannieR的技术博客
07-07 2078
定义 n个节点链结成一个链表，即为线性表的链式存储结构，因为此链表中的每个结点中只包含一个指针域，所以叫单链表。 头指针与头结点 头指针： a.指向第一个结点的指针，若有头结点，则指向头结点 b.头指针带有标识作用，常以头指针冠以链表的名字 c.无论链表是否为空，头指针均不为空。是链表的必要元素 头结点： a.为了操作统一和方便而设立，放在第一个元素
R语言基本知识
swrjlxc的博客
04-27 1万+
目前看的是R语言实战这本书 1、当输入png("lxc.png")这种需要加双引号。但是如果在括号中多加了一个双引号，那么"lxc.png"", R ide就会显示是函数输入的类型，显示加号，原因是双引号没有匹配，自己输错了，所以遇到没有匹配的直接输入缺失的匹配即可。 2、但是还有一点很重要，R给人感觉就是png("lxc.png")这个好像是打开画板，但是如果下面不画画是什么都没有的，并不是...
R语言初学者学习笔记
世靖的码场
07-30 1012
大数据分析，一般用R语言，老师布置了一些作业需要用到R语言，因为之前对R语言语法一无所知，所以在这里记录一下R语言的一些语法特性，和使用方式。 导入数据： 在右边点import导入 声明变量： 不用在前面写数据类型，直接 A A X student A A 访问元素： Student$num就是相当于访问student.num这一列 A[3,3]就是访问数组A的(3,3)
暨南大学830算法重点
最新发布
09-06
2. 数据结构：重点学习和理解各种基本数据结构，如线性表（如数组、链表）、栈、队列、树、图等，并掌握它们的基本操作和应用。 3. 动态规划：学习动态规划算法的基本思想和设计方法，了解其在问题求解中的应用，如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值