数据结构之顺序表

已于 2023-04-16 13:05:13 修改
阅读量414 收藏 3
点赞数 10
分类专栏： 算法与数据结构 文章标签： 数据结构
于 2023-04-16 12:57:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72867798/article/details/130181296
版权

🎉welcome🎉
✒️博主介绍：博主大一智能制造在读，热爱C/C++，会不定期更新系统、语法、算法、硬件的相关博客，浅浅期待下一次更新吧！
✈️算法专栏：算法与数据结构
😘博客制作不易，👍点赞+⭐收藏+➕关注

文章目录

前言

正如文章标题所说，本文将带大家了解数据结构中线性表之一——顺序表，那再描述这种数据结构之前，让我们先了解，什么是数据结构？数据结构，是计算机中用于存储数据的一种方式，这种方式是数据之间一种特定的关系，比如本博客的顺序表，再存储的时候是按照一段连续空间存储的，除了顺序表，还有很多种数据结构，如同是线性表的链表、栈等，那接下来博主将分享自己对于顺序表的见解。

顺序表

概念

顺序表是一段物理地址上连续空间存储的数据的数据结构，也就是我们常用的数组，但是数组是固定大小的，这也就是静态顺序表，相对，也存在动态顺序表，动态和静态的区别在于空间，会了动态的，可以改为静态的，本文将会讲解动态顺序表的增删查改。

动态顺序表

动态顺序表，顾名思义，它是可以动的，它的动是再空间上动，它的空间可以是无限大的，也就是说，再理想状态下，你的电脑可以存储多少数据，那动态的顺序表就可以存储多少数据。

动态顺序表结构体成员

动态顺序表，因为我们需要扩容，则需要两个数据，一个是当前的顺序表内部有多少个元素，一个是这个顺序表容量是多少，同时，表示内部多少个元素还可以知道我们的最后一个元素的下标是多少，让后面的尾删和尾插方便很多，那除了这两个元素还需要什么？我们的数据存放在哪里？所以这个时候，还需要一个成员用于存放数据，这里因为要存在int类型的数据，便以int类型来给大家演示：

typedef int SLDateType;//到时候想改存放数据类型，直接改掉这里，就改掉了全部

typedef struct SeqList
{
	SLDateType* a;//存放数据
	int size;//当前存放多少元素
	int capacity;//最大容量
}SeqList;

动态顺序初始化

那我们的动态顺序表的初始化应该是什么？size是0，因为初始化的时候，内部没有元素，那最大容量应该是多少？我们初始化顺序表的时候开辟的空间应该开辟多少？这是个问题，这里，开辟多少是凭借大家的喜好，那博主在这里初始化的时候开辟四个int类型的空间，同时，这里我们将使用#define来定义我们的初始化空间，这样在后期改的时候，直接改掉#define就改掉了全部：

 //放在.h文件当中
#define INIT_CAPACITY 4

//放在.c文件当中
//初始化顺序表
void SeqListInit(SeqList* ps)
{
	ps->a = (SeqList*)malloc(sizeof(SeqList) * INIT_CAPACITY);//开辟空间
	if (ps->a == NULL)
	{
		perror("SeqList");
	}
	ps->size = 0;//顺序表中的元素个数
	ps->capacity = INIT_CAPACITY;//顺序表容器的大小
}

动态顺序表动态实现

动态顺序表的动态实现其实不难，只需要再每次增加空间的时候，判断空间是否已经满了，如果满了，那就利用动态内存malloc或者realloc来开辟空间，那这个空间开辟多少才是最合适的呢？因为如果每次都多三个或者几个，那是不是开辟的太频繁了，是影响效率的，则我们每次都开辟到它原本容量的两倍，这个时候，开辟会变得不是很频繁，同时，对于动态顺序表存在弊端，那就是因为我们申请的空间是连续的，则对于这片空间而言，当我们删除了大量的数据的时候，后面的空间是空的，这个时候，因为是连续的，则不能释放掉空间，因为释放哪里，都是整个空间释放掉，意思是，再数据大量删除之后，顺序表是会浪费很多空间的，链表则不会存在这种问题，但是相比较链表，顺序表也存在优势，会再链表的博客提到，这里不做过多讲解，那接下来，就是动态顺序表的实现：

void SeqListdilata(SeqList* ps)
{
	assert(ps);//断言如果为空则说明传过来的数据有问题
	if (ps->size == ps->capacity)//当我们存放的元素个数和容器最大容量一样的时候，说明需要扩容
	{
		SeqList* tmp = (SeqList*)realloc(ps->a, sizeof(SeqList) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("dilata");
			return;
		}
		ps->a = tmp;//因为realloc开辟的空间的时候可能换到另一个地方
		ps->capacity *= 2;
	}
}

动态顺序表的增

对于顺序表而言，我们是可以在它的任意位置添加数据的，则对于顺序表，我们可以进行头插、尾插、任意位置的插入，那这里就一一讲解。

动态顺序表的头插

头插，在第一个位置插入数据，对于顺序表而言，头插会影响到全部数据，都向后挪一个格，因为从第一个元素开始挪动的话，会覆盖掉后面的数据，导致数据丢失，所以我们从最后面开始向后覆盖：

//顺序表头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	//判断是否需要扩容
	SeqListdilata(ps);
	//头插需要先将元素全部后移一位，将头空出来
	for (int i = ps->size - 1; i >= 0; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[0] = x;
	ps->size++;
}
动态顺序表的尾插

尾插，则不需要和头插一样，因为尾插就是在最后插入：

//顺序表尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	//先判断是否需要扩容
	SeqListdilata(ps);
	//然后插入数据,注意size要增加
   ps->a[ps->size++] = x;
}
动态顺序表的随机位置插入

随机插入，其实如同头插一样，只不过不用整体挪动，就只需要插入之后的部分挪动即可：

 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);//判断pos位置是否合法
	//先扩容
	SeqListdilata(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}

可以看到，三个插入的重复代码非常多，那其实，对于头插和尾插，可以直接调用随机插入，这里就不做演示了。

动态顺序表的删

删除和插入一样，分为了头删、尾删、随机位置的删除。

动态顺序表的头删

动态顺序表的头删和头插一样，都需要挪动全部数据，但是不同的时候，挪动的是除了头数据的全部数据，全部向前挪动一位，覆盖掉即可，但是这个是从第一个数据开始向前覆盖，不是向后覆盖了：

//顺序表头删
void SeqListPopFront(SeqList* ps)
{
	//断言检查
	assert(ps->a);
	//头删只需要讲全部元素前移一位即可
	for (int i = 0; i < ps->size; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}
动态顺序表的尾删

动态顺序表的尾删其实很简单，我们只要将size–，访问不到我们的尾部的这个元素，就相当于删除：

//顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	//断言检查
	assert(ps->a);
	//只需要size--，就访问不到最后的元素了
	ps->size--;
}
动态顺序表的随机位置删除

随机位置的删除和头删也是大同小异，也只是不用挪动全部元素，只需要挪动一个元素即可：

// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	//如同插入
	if (pos == 0)
		SeqListPopFront(ps);
	if (pos == ps->size)
	 	SeqListPopBack(ps);
	for (int i = pos+1; i < ps->size ; i++)
	{
		ps->a[i-1] = ps->a[i];
   }
	ps->size--;
}

如同随机位置位置插入一样，头删尾删也可以用随机位置删除。

动态顺序表的查找

当想要查找一个值在不在这个顺序表当中时，就要用到查找功能了，查找功能并不复杂，对于顺序表而言，我们的顺序表不是有序的，则只能用遍历，遍历的途中对比数据，如果找到，返回现在的下标，找不到就返回-1，如果这个顺序表是有序的，就可以用二分提升效率，这里用遍历：

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x) 
{
	assert(ps);
	//遍历数组，对比数组中和x是否相等，相等跳出去，返回x的下标
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
			return i;
	}
	return -1;
}

动态顺序表的其他操作

我们知道，对于用动态内存开辟的空间在堆上，如果不释放掉就会导致内存泄漏，那在不使用的时候，是不是要销毁掉当前的动态顺序表才可以，同时，对于顺序表是否插入删除数据，我们可以打印看看，那也就可以有打印操作：

//清空顺序表
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	//ps->a = NULL;
 	ps->size = ps->capacity = 0;
}
//打印顺序表
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
 	}
	printf("\n");
}

使用验证

#include"SeqLish.h"

int main()
{
	SeqList  a;
	SeqListInit(&a);

	for (int i = 0; i < 5; i++)
	{
		SeqListPushBack(&a, i);
	}
	for (int i = 5; i < 10; i++)
	{
		SeqListPushFront(&a, i);
	}
	SeqListPrint(&a);
	SeqListPopFront(&a);
	SeqListPrint(&a);
	SeqListPopBack(&a);
	SeqListPrint(&a);
	SeqListDestroy(&a);
	SeqListPrint(&a);
	return 0;
}

在这里插入图片描述

那通过试验，我们发现我们的顺序表代码是没有问题的，那这样我们的动态顺序表就写好了

源码

test.c

#include"SeqLish.h"

int main()
{
	SeqList  a;
	SeqListInit(&a);

	for (int i = 0; i < 5; i++)
	{
		SeqListPushBack(&a, i);
	}
	for (int i = 5; i < 10; i++)
	{
		SeqListPushFront(&a, i);
	}
	SeqListPrint(&a);
	SeqListPopFront(&a);
	SeqListPrint(&a);
	SeqListPopBack(&a);
	SeqListPrint(&a);
	SeqListDestroy(&a);
	SeqListPrint(&a);
	return 0;
}

seqlist.c

#include"SeqLish.h"

//顺序表扩容
void SeqListdilata(SeqList* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SeqList* tmp = (SeqList*)realloc(ps->a, sizeof(SeqList) * ps->capacity * 2);
		if (tmp == NULL)
		{
			perror("dilata");
			return;
		}
		ps->a = tmp;
		ps->capacity *= 2;
	}
}
//初始化顺序表
void SeqListInit(SeqList* ps)
{
	ps->a = (SeqList*)malloc(sizeof(SeqList) * INIT_CAPACITY);//开辟空间
	if (ps->a == NULL)
	{
		perror("SeqList");
	}
	ps->size = 0;//顺序表中的元素个数
	ps->capacity = INIT_CAPACITY;//顺序表容器的大小
}
//清空顺序表
void SeqListDestroy(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	//ps->a = NULL;
	ps->size = ps->capacity = 0;
}
//打印顺序表
void SeqListPrint(SeqList* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}
//顺序表尾插
void SeqListPushBack(SeqList* ps, SLDateType x)
{
	//先判断是否需要扩容
	SeqListdilata(ps);
	//然后插入数据,注意size要增加
	ps->a[ps->size++] = x;
}
//顺序表头插
void SeqListPushFront(SeqList* ps, SLDateType x)
{
	//同样判断是否需要扩容
	SeqListdilata(ps);
	//头插需要先将元素全部后移一位，将头空出来
	for (int i = ps->size - 1; i >= 0; i--)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[0] = x;
	ps->size++;
}
//顺序表头删
void SeqListPopFront(SeqList* ps)
{
	//断言检查
	assert(ps->a);
	//头删只需要讲全部元素前移一位即可
	for (int i = 0; i < ps->size; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;
}
//顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	//断言检查
	assert(ps->a);
	//只需要size--，就访问不到最后的元素了
	ps->size--;
}
// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x)
{
	assert(ps);
	//遍历数组，对比数组中和x是否相等，相等跳出去，返回x的下标
	for (int i = 0; i < ps->size; i++)
	{
		if (ps->a[i] == x)
			return i;
	}
	return -1;
}
 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	//先扩容
	SeqListdilata(ps);
	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);
	//如同插入
	if (pos == 0)
		SeqListPopFront(ps);
	if (pos == ps->size)
		SeqListPopBack(ps);
	for (int i = pos + 1; i < ps->size ; i++)
	{
		ps->a[i - 1] = ps->a[i];
	}
	ps->size--;
}

seqlist.h

#pragma once

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

typedef int SLDateType;
#define INIT_CAPACITY 4
typedef struct SeqList
{
	SLDateType* a;
	int size;
	int capacity;
}SeqList;

// 对数据的管理:增删查改 
void SeqListInit(SeqList* ps);
void SeqListDestroy(SeqList* ps);

void SeqListPrint(SeqList* ps);
void SeqListPushBack(SeqList* ps, SLDateType x);
void SeqListPushFront(SeqList* ps, SLDateType x);
void SeqListPopFront(SeqList* ps);
void SeqListPopBack(SeqList* ps);

// 顺序表查找
int SeqListFind(SeqList* ps, SLDateType x);
// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDateType x);
// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos);

🚀专栏：算法与数据结构
🙉都看到这里了，留下你们的👍点赞+⭐收藏+📋评论吧🙉

封心锁爱的前夫哥
关注
  • 10
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
数据结构之顺序表.rar
04-07
数据结构之顺序表
php数据结构之顺序链表与链式线性表示例
10-18
主要介绍了php数据结构之顺序链表与链式线性表,结合实例形式较为详细的分析了php实现顺序链表与链式线性表的各种常用操作技巧,需要的朋友可以参考下
C#数据结构之顺序表(SeqList)实例详解
01-01
本文实例讲述了C#数据结构之顺序表(SeqList)实现方法。分享给大家供大家参考，具体如下： 线性结构(Linear Stucture)是数据结构(Data Structure)中最基本的结构，其特征用图形表示如下： 即：每个元素前面有且只有...
Python数据结构之顺序表的实现代码示例
09-21
主要介绍了Python数据结构之顺序表的实现代码示例，简单介绍了顺序表的相关内容，然后分享了其代码示例，具有一定参考价值，需要的朋友可以了解下。
数据结构C++顺序表
03-04
基于C++的顺序表数据结构，带主程序，可直接运行，使用时直接带入头文件即可。
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
数据结构顺序表操作示例
09-04
主要介绍了数据结构顺序表操作示例,其中有在第I个元素前插入数据x，元素从0开始计数、删除第i个元素，元素从0开始计数的方法,需要的朋友可以参考下
数据结构实验 顺序表和链表
10-08
数据结构实验 顺序表和链表
PTA—C语言数据结构：顺序表.ppt
10-11
PTA平台数据结构课程顺序表参考答案
数据结构之顺序表的创建、插入、删除、定位 源码
04-12
数据结构之顺序表的创建、插入、删除、定位
C++数据结构顺序表删除操作
08-26
C++数据结构顺序表删除操作..................................................................................................................................................................................
合工大数据结构顺序表实验
04-14
18级合工大数据结构实验
数据结构顺序表和链表的相关操作
06-30
1.依次从键盘读入数据，建立顺序表和链表；2.求顺序表的长度；3.根据指定条件能获取元素；4.实现在指定位置插入和删除元素的功能 主菜单设计要求： 程序运行后创建顺序表和链表，之后给出9个菜单项的内容和输入提示...
数据结构之顺序表实现
12-10
对于数据结构中顺序表相应功能的实现，在黑框中的操作
数据结构-顺序表.zip
11-03
压缩包中共有两个文件，一个是顺序表的执行代码cpp文件，一个是顺序表的word文件，顺序表的word文件中写有代码所拥有的功能以及各功能的...不过数据结构就是要会C语言基础才开始学的，祝愿看了我资源的各位前程似锦呀！
鸿蒙轻内核A核源码分析系列二 数据结构-位图操作
最新发布
maniuT的博客
06-11 1039
位操作模块提供对32位无符号整数数值的bit位进行操作，bit位取值为0-31，以0开始计算，从左向右，第0位，第1位。。。第31位等。⑴处定义的宏如下，也就是十进制31。如果传入的比特位pos大于31，会通过逻辑与运算截断，只取低5位，确保不会大于31，避免溢出。⑵处定义的位图掩码全是1。在文件中定义了常用的位操作相关的宏。宏根据参数x计算出需要操作第几个状态字，由于计算状态字的使用的是UINTPTR，状态字可以是32位、也可以是64位。后文，我们默认以32位进行讲解。宏传入的参数是位操作的开始bit。
数据结构--第七章--树和二叉树
2302_80052051的博客
06-11 314
前序+中序可以确定一个二叉树；中序+后序可以确定一个二叉树。，将数据元素组织成层次结构，元素间属于。二叉树的定义是递归定义。
数据结构--线性表和串
code袁的博客
06-08 815
🦁作者简介：一名喜欢分享和记录学习的在校大学生💥个人主页code袁💥个人QQ🐯个人wechat：code8896线性表是一种常见的数据结构，它是具有相同数据类型的有限序列。线性表中的元素之间存在一种顺序关系，可以通过元素在表中的位置来访问和操作。串是由零个或多个字符组成的有限序列，也可以理解为字符串。串是计算机科学中最基本的数据类型之一，常用于表示文本信息。手动码字，如有错误，欢迎在评论区指正💬~你的支持就是我更新的最大动力💪~
数据结构顺序表C++
09-06
- *1* [数据结构顺序表c++代码](https://download.csdn.net/download/qq_46546083/13458006)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

封心锁爱的前夫哥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值