【数据结构】顺序表和链表

于 2023-11-06 22:03:55 发布
阅读量1.2k 收藏 19
点赞数 17
分类专栏： 数据结构 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64476561/article/details/134255537
版权

顺序表和链表

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

在这里插入图片描述

2.顺序表

2.1概念及结构

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存

储。在数组上完成数据的增删查改。

顺序表一般可以分为：

\1. 静态顺序表：使用定长数组存储元素。

在这里插入图片描述

\2. 动态顺序表：使用动态开辟的数组存储。

在这里插入图片描述

2.2 接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实现动态顺序表。

typedef int SLDataType;
// 顺序表的动态存储
typedef struct SeqList
{
  SLDataType* array;  // 指向动态开辟的数组
  size_t size ;       // 有效数据个数
  size_t capicity ;   // 容量空间的大小
}SeqList;
// 基本增删查改接口
// 顺序表初始化

void SeqListInit(SeqList* psl);
// 检查空间，如果满了，进行增容
void CheckCapacity(SeqList* psl);
// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x);
// 顺序表尾删
void SeqListPopBack(SeqList* psl);
// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x);
// 顺序表头删
void SeqListPopFront(SeqList* psl);
// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x); 
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos);
// 顺序表销毁
void SeqListDestory(SeqList* psl);
// 顺序表打印
void SeqListPrint(SeqList* psl);

头插实现：

头插的实现需要先将顺序表中的数据逐个往后挪动，再将数据插入下标为0的位置。

在这里插入图片描述

头删实现：

头删只要将顺序表中的数据逐个往前覆盖即可，注意后面需要将顺序表中的有效个数减1，即ps->size-1。

在这里插入图片描述

顺序表在pos位置插入x：

在这里插入图片描述

顺序表删除pos位置的值：

在这里插入图片描述

2.3 顺序表的扩容

顺序表在用realloc扩容时有两种情况：

  1. 后面内存空间足够：原地扩容，扩容后起始地址不变。
  2. 后面空间不够扩容：异地扩容，扩容后起始地址改变。

在这里插入图片描述

2.4 顺序表的问题及思考

问题：

优点：

  1. 尾插尾删足够快
  2. 下标的随机访问和修改

缺点：

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

思考：如何解决以上问题中的缺点呢？下面给出了链表的结构来看看。

3.链表

3.1 链表的概念及结构

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

在这里插入图片描述

物理结构：

在这里插入图片描述

注意:

  1. 从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续。
  2. 现实中的结点一般都是从堆上申请出来的。
  3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。

假设在32位系统上，结点中值域为int类型，则一个节点的大小为8个字节，则也可能有下述链表:

在这里插入图片描述

3.2 链表的分类

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

\1. 单向或者双向

在这里插入图片描述

\2. 带头或者不带头

在这里插入图片描述

\3. 循环或者非循环

在这里插入图片描述

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

在这里插入图片描述

原因

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

3.3 单向链表的实现

// 1、无头+单向+非循环链表增删查改实现
typedef int SLTDateType;
typedef struct SListNode
{
 SLTDateType data;
 struct SListNode* next;
}SListNode;
// 动态申请一个结点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
// 分析思考为什么不在pos位置之前插入？
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
// 分析思考为什么不删除pos位置？
void SListEraseAfter(SListNode* pos);

3.4单向链表的接口实现

#define _CRT_SECURE_NO_WARNINGS 1
#include"SList.h"


//打印
void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	//while (cur != NULL)
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

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

	return newnode;

}

尾插  phead是plist的形参   //开始就有链表
//void SLTPushBack(SLTNode* phead, SLTDataType x)
//{
//	SLTNode* newnode = BuySListNode(x);
//	SLTNode* tail = phead;
//	while (tail->next != NULL)
//	{
//		tail = tail->next;
//	}
//	tail->next = newnode;
//}

//尾插  //包括一开始没有链表
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);

	SLTNode* newnode = BuySListNode(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)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);

	SLTNode* newnode = BuySListNode(x);

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

//尾删
void SLTPopBack(SLTNode** pphead)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);

	//1.空
	assert(*pphead);
	//2、一个节点
	//3、一个以上节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	else
	{
		//方法1.
		SLTNode* tailPrev = NULL;
		SLTNode* tail = *pphead;
		while (tail->next)
		{
			tailPrev = tail;
			tail = tail->next;
		}
		free(tail);
		tailPrev->next = NULL;
		
		方法2.
		//SLTNode* tail = *pphead;
		//while (tail->next->next)
		//{
		//	tail = tail->next;
		//}
		//free(tail->next);
		//tail->next = NULL;
	}
}

//头删
void SLTPopFront(SLTNode** pphead)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);

	//空
	assert(*pphead);

	//非空
	SLTNode* newhead = (*pphead)->next;
	free(*pphead);
	*pphead = newhead;
}

//查找是否有x这个数,找到返回指向该数的指针
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
	SLTNode* cur = phead;
	while (cur)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

//在pos位置前插
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);
	assert(pos);

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

//在pos位置后插
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);

	SLTNode* newnode = BuySListNode(x);
	
	//下面两句不能交换位置，否则会成环
	newnode->next = pos->next;
	pos->next = newnode;
}

//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	//pphead不存在为空的情况，所以要断言
	assert(pphead);
	assert(pos);

	if (*pphead == pos)
	{
		SLTPopFront(pphead);
	}
	//else if (pos->next == NULL)
	//{
	//	SLTPopBack(pphead);
	//}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}		
		//free(prev->next);//不要free，不然这个节点后面全没了
		prev->next = pos->next;		
	}
}

//删除pos后一个位置
void SLTEraseAfter(SLTNode* pos)
{
	//
	assert(pos);

	//检测pos是否是尾节点
	//assert(pos->next);//暴力检测
	if (pos->next == NULL)//温和检测
	{
		return NULL;
	}

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

}


//不给头，删除pos位置
void SLTEraseNoFront(SLTNode* pos)
{
	//检测pos是否是尾节点
	//assert(pos->next);//暴力检测
	if (pos->next == NULL)//温和检测
	{
		return NULL;
	}

	SLTNode* posNext = pos->next;
	pos->data = posNext->data;
	pos->next = posNext->next;
	free(posNext);
	posNext = NULL;
}

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

	SLTNode* cur = *pphead;
	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);

		cur = next;
	}
	*pphead = NULL;
}

3.5双向链表的实现

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

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

3.6双向链表的接口实现

LTNode* BuyLTNode(LTDataType x)
{
	LTNode* node = (LTNode*)malloc(sizeof(LTNode));
	if (node == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

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

	return node;
}

LTNode* LTInit()
{
	LTNode* phead = BuyLTNode(0);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}
//打印
void LTPrint(LTNode* phead)
{
	assert(phead);

	printf("phead<=>");
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d<=>", cur->data);
		cur = cur->next;
	}
	printf("\n");
}
//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
	assert(phead);

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

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

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

	//插入phead位置的前面(即链表结尾位置)，相当于尾插
	LTInsert(phead, x);
}
//尾删
void LTPopBack(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	/*LTNode* tail = phead->prev;
	LTNode* tailPrev = tail->prev;
	free(tail);

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

	//删除phead->prev位置的节点相当于尾删
	LTErase(phead->prev);
}
//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
	assert(phead);

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

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

	//LTNode* newnode = BuyLTNode(x);
	//LTNode* first = phead->next;

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

	//插入phead->next位置的前面，相当于头插
	LTInsert(phead->next, x);
}
//头删
void LTPopFront(LTNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

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

	//free(first);

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


	//删除phead->next位置的节点，相当于头删
	LTErase(phead->next);
}

int LTSize(LTNode* phead)
{
	assert(phead);

	int size = 0;
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		++size;
		cur = cur->next;
	}

	return size;
}

// 从pos位置前插
void LTInsert(LTNode* pos, LTDataType x)
{
	
	assert(pos);

	LTNode* posPrev = pos->prev;
	LTNode* newnode = BuyLTNode(x);

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

// 从pos位置删除
void LTErase(LTNode* pos)
{

	assert(pos);
	LTNode* posPrev = pos->prev;
	LTNode* posNext = pos->next;

	free(pos);

	posPrev->next = posNext;
	posNext->prev = posPrev;
}

LTNode* LTFind(LTNode* phead, LTDataType x)
{
	assert(phead);

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

//销毁
LTNode* LTDetory(LTNode* phead)
{
	assert(phead);
	LTNode* cur = phead->next;	

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

	free(phead);
}

4.顺序表和链表的区别

在这里插入图片描述

备注：缓存利用率参考存储体系结构以及局部原理性。
扩展知识：《与程序员相关的CPU缓存知识》 https://coolshell.cn/articles/20793.html

敲敲er
关注
  • 17
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
数据结构顺序表和链表的相关操作
06-30
1.依次从键盘读入数据，建立顺序表和链表；2.求顺序表的长度；3.根据指定条件能获取元素；4.实现在指定位置插入和删除元素的功能 主菜单设计要求： 程序运行后创建顺序表和链表，之后给出9个菜单项的内容和输入提示...
数据结构实验 顺序表和链表
10-08
数据结构实验 顺序表和链表
顺序表和链表
passion
08-03 2888
顺序表和链表的简单介绍和实现
数据结构-顺序表与链表详解
m0_62918577的博客
11-05 1528
顺序表概念及分类，以及动态顺序表的接口实现 链表的概念及结构以及无头单向非循环链表的接口实现 在不同方面解析顺序表和链表的区别
数据结构 | 顺序表及链表
Nice_W的博客
12-28 635
数据结构中的线性表是一种非常基础的数据结构，在实际运用中也非常广泛，本文主要介绍线性表中顺序表和链表。
【数据结构】顺序表与链表基础知识的超详细详解
小刘好好学习的博客
05-29 713
线性表、顺序表、链表的基础知识与编码实现
数据结构顺序表和链表（超详细）
08-14
创建返回链表的头结点.// 双向链表销毁// 双向链表打印// 双向链表尾插// 双向链表尾删// 双向链表头插// 双向链表头删// 双向链表查找// 双向链表在pos的前面进行插入// 双向链表删除pos位置的结点
数据结构试验1-链表和顺序表
03-08
数据结构链表和顺序表实验源码，没有实验报告，需要下载。
数据结构顺序表、链表和数组是逻辑结构还是物理（存储）结构？ 数组和链表.pdf
04-18
数据结构顺序表、链表和数组是逻辑结构还是物理（存储）结构？ 数组和链表.pdf
数据结构顺序表和4个链表的代码
09-13
数据结构顺序表和4个链表的代码，对应到我的博客数据结构顺序表和链表
数据结构-C语言描述（顺序表、链表）
最新发布
04-01
水一下学校的实验报告，注释没有认真写，勿喷。
数据结构与算法-顺序表（链表篇）
09-09
代码资源
php数据结构之顺序链表与链式线性表示例
10-18
主要介绍了php数据结构之顺序链表与链式线性表,结合实例形式较为详细的分析了php实现顺序链表与链式线性表的各种常用操作技巧,需要的朋友可以参考下
头歌 顺序表，链表，循环队列的基本操作和应用答案。
05-03
头歌数据结构的题目： 顺序表的基本操作和应用 链表的基本操作和应用， 循环队列的应用 同时还有一些附加题，n皇后和钓鱼
[数据结构] - 顺序表与链表详解
m0_72940975的博客
12-05 745
一篇文章帮你搞定顺序表和链表！
【顺序表和链表】
qq_43727529的博客
03-29 1515
文章目录一：线性表1.1 顺序表1.1.1 接口实现1.2 链表1.2.1 链表与数组的区别1.2.2 结构体的自引用1.2.3 链表的分类 一：线性表 线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表有：顺序表，链表，栈，队列，字符串等。 线性表在逻辑上是线性结构，也就是说是一条连续的实线，但其实在物理结构上不一定连续，其中线性表在储存的时候，通常以数组和链式结构的形式存储。 1.1 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性
数据结构顺序表和链表
09-06
数据结构中，顺序表和链表是两种不同的存储结构。 顺序表是一种线性结构，它通过一段物理地址连续的存储单元来存储数据元素，并且采用数组的形式进行存储。顺序表在数组上完成数据的增删查改操作，同时记录表的长度...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

敲敲er

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

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

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

打赏作者

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

抵扣说明：

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

余额充值