顺序表和链表的实现

已于 2022-08-08 19:46:41 修改
阅读量301 收藏 4
点赞数 3
分类专栏： c语言 数据结构 文章标签： 经验分享
于 2022-08-08 19:44:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gemgod/article/details/126234739
版权
本文详细介绍了顺序表和链表的实现，包括单向链表和带头双向链表。顺序表使用动态数组实现，支持尾插、头插、查找、插入和删除操作，但存在空间浪费和增容开销。链表则分为单向和双向，动态申请节点，插入和删除操作更灵活，但需要额外的空间存储指针。带头双向链表在中间插入时效率更高，且便于遍历。文章探讨了不同链表结构在实际应用中的优缺点。
摘要由CSDN通过智能技术生成

顺序表和链表的实现

文章目录

1.顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存 储。在数组上完成数据的增删查改。

函数接口实现:

void SeqListInit(SeqList* ps)
{
	assert(ps);
	ps->capacity = 0;
	ps->size = 0;
	ps->a = NULL;
}
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
		ps->capacity = 0;
		ps->size = 0;
	}
}
void checklist(SeqList* ps)
{
	if (ps->capacity <= ps->size)
	{
		int newcount = ps->capacity == 0 ? 4 : ps->capacity * 2;
		ps->capacity = newcount;
		int *tmp= (int*)realloc(ps->a, sizeof(SLDateType) * newcount);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(1);
		}
		ps->a = tmp;
	 }
 }

void SeqListPrint(SeqList* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d->", ps->a[i]);
	}
	printf("NULL\n");
}
//尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	assert(ps);
	checklist(ps);
	ps->a[ps->size] = x;
	ps->size++;

}
//头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	assert(ps);
	checklist(ps);
	int i = ps->size;
	while (i>0)
	{
		ps->a[i] = ps->a[i - 1];
		i--;
	}
	ps->a[0] = x;
	ps->size++;
}
//头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	if (ps->size == 0)
	{
		return;
	}
	int i = 1;
	while (i < ps->size)
	{
		ps->a[i - 1] = ps->a[i];
		i++;
	}
	ps->size--;
}
//尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	if (ps->size == 0)
	{
		return;
	}
	ps->size--;
}

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, size_t pos, SLDateType x)
{
	assert(ps);
	checklist(ps);
	for (int i = ps->size; i>pos; i--)
	{
		ps->a[i] = ps->a[i - 1];
	}
	ps->a[pos] = x;
	ps->size++;
}
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, size_t pos)
{
	assert(ps);
	for (int i = pos; i<ps->size-1; i++)
	{
		ps->a[i] = ps->a[i+1];
	}
	ps->size--;
}

在本次实现中,使用了动态版本,使顺序表的内存可以进行更改.

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

2.链表

在此介绍不带头的单向链表,和带头的双向链表

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

1.单向链表

函数接口实现:

#define _CRT_SECURE_NO_WARNINGS 1
#include "list.h"
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{
	SN* newnode = (SN*)malloc(sizeof(SN));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
// 单链表打印
void SListPrint(SListNode* plist)
{
	SN* cur = plist;
	while (cur!=NULL)
	{
		printf("%d->",cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{
	assert(pplist);
	SN* newnode = BuySListNode(x);
	SN* cur = *pplist;
	if (cur == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		while (cur->next != NULL)
		{
			cur = cur->next;
		}
		newnode->next = cur->next;
		cur->next = newnode;
	}
	
}
// 单链表的头插
void SListPushFront(SListNode**pplist, SLTDateType x)
{
	assert(pplist);
	SN* newnode = BuySListNode(x);
	newnode->next = *pplist;
	*pplist = newnode;

}
// 单链表的尾删
void SListPopBack(SListNode** pplist)
{
	assert(*pplist!=NULL);
	assert(pplist);
	SN* list = *pplist;
	SN* tail = list->next;
	if (tail == NULL)
	{
		free(list);
		*pplist = NULL;
	}
	else
	{
		while (tail->next!=NULL)
		{
			list = tail;
			tail = list->next;
		}

		list->next = tail->next;
		free(tail);
		tail = NULL;
	}

}
// 单链表头删
void SListPopFront(SListNode** pplist)
{
	assert(*pplist != NULL);
	assert(pplist);
	SN* list = *pplist;
	*pplist = list->next;
	free(list);
	list = NULL;
}
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{
	SN* cur = plist;
	while (cur != NULL)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{
	assert(pos);
	SN* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{
	assert(pos);
	SN* tmp = pos->next;
	pos->next = tmp->next;
	free(tmp);
	tmp = NULL;
}
// 单链表的销毁
void SListDestroy(SListNode**plist)
{
	assert(plist);
	if (*plist == NULL)
	{
		return;
	}
	SN* list = *plist;
	SN* tmp = (*plist)->next;
	while (tmp != NULL)
	{
		free(list);
		list = tmp;
		tmp = list->next;
	}
	free(list);
	list = NULL;
}

在此解释头插和头删使用二级指针的原因:

在此之前,在函数接口内修改当前的变量的值时,只能传递该变量的地址,通过解引用操作来修改该变量的值.

所以此时head指向的链表的第一个节点的地址或者NULL,head是一级指针,修改head的值需要二级指针.

再次提及一下带头的单向链表,及创建一个哨兵位,哨兵位的next指向该链表的第一个节点,使用哨兵位的优点,不需要使用二级指针,剩下的优点,将会在下次关于链表的博客总结出来.

image-20220808193256731

2.带头的双向链表

函数接口实现:

#define _CRT_SECURE_NO_WARNINGS 1
#include"test.h"
ListNode* ListCreate()
{
	ListNode* head = (ListNode*)malloc(sizeof(ListNode));
	if (head == NULL)
	{
		exit(-1);
	}
	head->_next = head;
	head->_prev = head;
	return head;
}
// 双向链表销毁
void ListDestory(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->_next;
	ListNode* tmp;
	while (cur != pHead)
	{
		tmp = cur;
		cur = cur->_next;
		free(tmp);
	}
	free(pHead);
}
// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->_next;
	while (cur!=pHead)
	{
		printf("%d", cur->_data);
		if(cur->_next!=pHead)
		printf("<>");
		cur = cur->_next;
	}
	printf("\n");
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->_data = x;
	ListNode* cur = pHead->_prev;
	newnode->_next = cur->_next;
	cur->_next = newnode;
	newnode->_prev = cur;
	pHead->_prev = newnode;
}
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead);

	ListNode* cur = pHead->_prev;
	if (cur == pHead)
	{
		printf("该双向链表为空,无法删除\n");
		return;
	}
	ListNode* tmp = cur;
	cur = tmp->_prev;
	pHead->_prev = cur;
	cur->_next = tmp->_next;
	free(tmp);
}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
	assert(pHead);
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->_data = x;
	newnode->_next = pHead->_next;
	pHead->_next = newnode;
	newnode->_prev = pHead;
}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead);
	ListNode* cur = pHead->_next;
	if (cur == pHead)
	{
		printf("该双向链表为空,无法删除\n");
		return;
	}
	pHead->_next = cur->_next;
	free(cur);
	cur = pHead->_next;
	cur->_prev = pHead;
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
	ListNode* cur = pHead->_next;
	while (cur != pHead)
	{
		if (cur->_data == x)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* cur = pos;
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	newnode->_data = x;
	newnode->_next = cur;
	newnode->_prev = cur->_prev;
	cur = cur->_prev;
	cur->_next = newnode;
	cur = pos;
	pos->_prev = newnode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
	ListNode* cur = pos;
	ListNode* tmp = pos->_prev;
	tmp->_next = cur->_next;
	free(cur);
	cur = tmp->_next;
	cur->_prev = tmp;
}

image-20220808193310394

由于带头的双向链表可以快速找个前面的节点和后面的节点,中间插入的效率会比单向链表高不少.

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

3.顺序表,链表对比

image-20220808193757535

image-20220808193310394

由于带头的双向链表可以快速找个前面的节点和后面的节点,中间插入的效率会比单向链表高不少.

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

3.顺序表,链表对比

image-20220808193757535

文章照片来自:比特科技

sleepymonstergod
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
数据结构 用顺序表和链表实现表的连接
03-31
用顺序表和链表实现表的连接 数据结构 用C语言编写的小程序
线性表的顺序表和链表简单实现--Java
weixin_53050118的博客
10-17 393
当我们使用SequenceList时，先new SequenceList(5)创建一个对象，创建对象时就需要指定容器的大小，初始化指定大小的数组来存储元素，当我们插入元素时，如果已经插入了5个元素，还要继续插入数据，则会报错，就不能插入了。顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组连续的存储单位，依次存储线性表中的各个元素，使得线性表在逻辑上相邻的数据元素存储在相邻的物理单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。这个问题有没有解决方案呢？
Java基础之顺序表和链表的实现
qq_49912778的博客
01-14 231
由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。其中数组是一种特殊的线性结构，在数组中保存的元素允许出现空的，线性结构不能出现空洞。顺序表对象是在数组对象的基础上构建的，在构建顺序表时，我们首先要初始化容量，在数据元素个数与容量相等时，进行容量扩充，使该顺序表不会出现溢出的现象。在数组不在能够放入新的元素时，进行扩容操作，保证数组容量够用。
【数据结构】顺序表/链表的运算及实现
weixin_44799923的博客
12-01 757
数据结构的基础知识，包括顺序表/链表运算及实现
顺序表--链表实现
qq_43710269的博客
03-24 535
链表 链表是一种在物理存储上无规则的存储结构，由指针将每个数据元素来串联起来。 链表可以从单向双向、带头不带头、循环非循环来进行分类，最常用的是无头单向非循环链表和带头双向链表。 无头单向链表：结构简单实现容易，但是一般不会用来存储数据，更多的是用来实现一些其他数据结构的子结构，如哈希桶、邻接表等。 ​ 带头双向循环链表：结构复杂，一般用来存储数据，其数据结构带来许多操作的优势。 单向链表结构定义： typedef int SLTypeData; typedef struct SListNode {
数据结构笔记（三）-- 链式实现顺序表
m0_43609475的博客
05-24 759
带有头结点的单链表的实现 一、链表概述 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 二、线性表的单链表存储数据 以存储数据为整型为例 typedef int ElemType; /* 定义抽象数据类型ElemType为整型 */ 三、线性表的单链表存储结构 线性表的单链表存储结构图示 代码示 //线性表的单链表存储结构 typedef struct Node { ElemType data; //代表数据域 struct Node
数据结构 | 顺序表及链表
Nice_W的博客
12-28 802
数据结构中的线性表是一种非常基础的数据结构，在实际运用中也非常广泛，本文主要介绍线性表中顺序表和链表。
顺序表和链表简单介绍及实现
qq_48042235的博客
09-24 162
顺序表和链表的简单介绍及部分实现
顺序链表的实现
sing_Hwang的博客
09-09 1955
顺序表相当于一个结构体，一个结构体就是一张表，结构体里面两个成员，一个成员是数组，一个是表示数组实际长度的int型变量
数据结构:链表和顺序表的实现
weixin_51654781的博客
03-26 1019
线性表 ​ 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 文章目录顺序表静态顺序表(使用定长数组存储数组元素)动态顺序表(使用动态开辟存储数组元素)头文件源文件链表无头单向非循环链表头文件源代码带头双向循环链表头文件源代码总结链表和顺序表的对比 顺
【数据结构】顺序表&链表的实现
qq_40376612的博客
02-09 324
顺序表和链表的实现
顺序表的链式实现-单链表
对自己笑
10-16 422
一、线性链表   逻辑上相邻的两个元素在物理存储单元上不一定是不相邻的，这就是链表。 二、单链表具体实现 头文件： #include<stdio.h> #include<stdlib.h> #include<Windows.h> typedef int ElemType; typedef struct LNode{ ElemType data; LNode...
java数据结构与算法之顺序表与链表深入分析
热门推荐
zejian的博客
11-05 3万+
开篇直接奔主题，无论是顺序表还是链表，它们都是线性表的一种，用比较官方的话来讲，线性表是其组成元素间具有线性关系的一种线性结构，而我们恰好可以采用顺序存储和链式存储结构来表示线性表。接下来将从以下几点出发分析线性表的设计与实现。 线性表抽象数据类型概述 线性表的顺序存储设计与实现顺序表 1 顺序存储结构的设计原理概要 2 顺序存储结构的实现分析 3 顺序存储结构的效率分析 线性表的链式存
数据结构-线性表（链式存储结构）
weixin_46440790的博客
09-20 757
线性表（链式存储结构） 特点： 用一组任意的存储单元存储线性表的数据结构，这组存储单元可以是连续的，也可以是不连续的。 对数据结构ai来说，除了存储其本身的信息之外，还需存储一个指示其后继的信息（即直接后继的存储位置）。 数据域：存储数据元素信息的域。 指针域：存储直接后继位置的域。 数据域+指针域=结点 n个结点链结成一个链表，即为线性表的链式存储结构。因为此链表的每个结点只含一个指针域，所以叫做单链表。 链表中的第一个结点的存储位置（地址）也叫做头指针，最后一个结点指针为空，通常用NULL或者"^"表示
线性表(顺序表,链表的表示和实现)
癫狂的痴迷
03-06 8160
本篇文章将从以下几点进行讲解:  1.线性表的类型定义  2.1线性表的顺序表示和实现  2.2线性表的链式表示和实现 1.线性表的类型定义: 接下来介绍下什么是线性表,学习每一样东西都要从定义下手. 由n( n>= 0 )个数据特性相同的元素构成的有限序列称为线性表//这个是官方给出的定义有点生僻 换句话说,统一线性表中的元素必定 具有相
数据结构篇：实现顺序表和单链表
潘浩的博客
07-14 665
前言许久没写博客了，7月初去广州一家公司面试了实习生的岗位，是一家小型的创业公司，目前主要做外包业务。作为人生中第一次面试，感觉还是挺宝贵的。刚到广州的时候下着雨，一个人为了一件事走在一个陌生的城市，是一种熟悉又陌生的感觉。广州这座城市给我的感觉：安静，一切都井然有序，繁华，但你关注的绝对不是他的繁华，然后就是四通八达的地铁，我几天的出行全都是地铁，深切的感受到广州交通的发达。 第二天上午
数据结构之顺序表和单链表的实现-C语言版
小北的博客
09-27 1503
数据结构之顺序表和单链表的实现-C语言版 一、顺序表 1.顺序表的创建 //Authors:xiaobei void CREATE(SqList *L) { int i; printf("请输入学生的个数:"); scanf("%d",&L->length); for(i=0;i<L->length;i++) { ...
顺序表和链表详解及实现
weixin_34262482的博客
02-11 528
首先了解顺序表和链表的概念 1.顺序表（类似STL库中的vector） 顺序表是在计算机内存中以数组形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。 线性表采用顺序存储的方式称为顺序表。 优点： （1）空间利用率高（连续存放） （2）存取速度高效，通过下标直接存储和读取。 缺点： （1）插入和删除比较慢。（插入或删除一个元素时需要遍历移动元素来重新排一次顺...
顺序表和链表的实现附录
最新发布
05-28
顺序表和链表都是数据结构中常见的线性表。顺序表采用数组实现，而链表则采用指针实现。二者各有优劣，下面我来简单介绍一下它们的实现及特点。 1.顺序表的实现： 顺序表是一种连续存储的线性表，可以通过下标直接...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

sleepymonstergod

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

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

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

打赏作者

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

抵扣说明：

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

余额充值