数据结构——顺序表

已于 2023-10-08 14:38:41 修改
阅读量1.6k 收藏 6
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 算法 c++ c语言
于 2023-04-12 10:00:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aqlll_/article/details/130098051
版权

顺序表

一、前言

初次接触数据结构，我们最先遇到的、且最简单的是线性表中的顺序表，所谓顺序表，就是与1234567…依次排序一样。

线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。

二、两种顺序表

顺序表有两种实现方法：一是静态顺序表，二是动态顺序表。

2.1静态的顺序表

我们先来看看静态的顺序表：
我们最最常见的数组就是一个静态的顺序表，我们存在数组里的数据，在内存中是连续存储的。
在这里插入图片描述

静态顺序表虽然很方便，但是有一个弊端：

当我已经在a[15]数组中存放了15个元素了，依然想在后面再存储16、17…时，此时就数组越界了，即使再创建一个数组来存放16、17…这两个数组的内存也不一定是连续的，此时就不能称之为一个顺序表了，而变成了两个独立的顺序表。
此时就需要使用动态的顺序表了。

2.2动态的顺序表

使用malloc、celloc、realloc等动态内存分配函数来动态管理内存。
如下图，首先用malloc创建15*sizeof(int)个字节大小的空间，当这60个字节的内存已经存满时，就使用realloc函数在刚刚创建的60个字节空间后面再扩容8个字节的大小空间，以便存入16和17两个数据。
在这里插入图片描述

以下将分为三个模块代码展示动态的顺序表的基本逻辑。

三、动态顺序表的实现

三个模块是指在同一个项目中创建三个文件包括：
1个头文件：SeqList.h
2个源文件：SeqList.c 、 Test.c

3.1 SeqList.h

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

typedef int SLDataType;
#define INIT_CAPACITY 4//顺序表的初始大小


typedef struct SeqList
{
	SLDataType* a;
	int size;		// 有效数据的个数
	int capacity;	// 空间容量
}SL;


//增删查改
void SLInit(SL* ps);							//初始化
void SLDestory(SL* ps);							//销毁
void SLPrint(SL* ps);							//打印
void SLCheckCapacity(SL* ps);					//扩容
void SLPushBack(SL* ps, SLDataType x);			//尾插
void SLPopBack(SL* ps);							//尾删
void SLPushFront(SL* ps, SLDataType x);			//头插
void SLPopFront(SL* ps);						//头删
void SLInsert(SL* ps, int pos, SLDataType x);	//在某个位置插入
void SLErase(SL* ps, int pos);					//删除某个位置的数据
int SLFind(SL* ps, SLDataType x);				//查找某个数据的位置

3.2 SeqList.c

#include"SeqList.h"

void SLInit(SL* ps)
{
	//暴力检查
	assert(ps);
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->capacity = INIT_CAPACITY;
	ps->size = 0;
}

void SLDestory(SL* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

void SLPrint(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SLCheckCapacity(SL* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDataType* pf = NULL;
		pf = (SLDataType*)realloc(ps->a,
			sizeof(SLDataType) * ps->capacity * 2);
		if (pf == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = pf;
		ps->capacity *= 2;
	}
}

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	//扩容
	SLCheckCapacity(ps);
	ps->a[ps->size++] = x;
}

void SLPopBack(SL* ps)
{
	assert(ps);
	//两种判断size是否为0
	//1.size已经为0的时候，断言的方式来暴力提醒非法访问了
	assert(ps->size > 0);
	//2.不提醒，直接返回
	//if (ps->size == 0)
	//{
	//	return;
	//}
	ps->size--;
}

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	//扩容
	SLCheckCapacity(ps);
	for (int i = ps->size; i > 0; --i)
	{
		ps->a[i] = ps->a[i - 1];
	}
	//增加到第一个
	ps->a[0] = x;
	ps->size++;
}

void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);
	//往前挪动数据
	for (int i = 0; i < ps->size; ++i)
	{
		ps->a[i] = ps->a[i + 1];
	}
	ps->size--;

}

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}

void SLErase(SL* ps, int pos)
{
	assert(ps);
	//在这里已经间接检查了size是否为0，所以assert(ps->size)就没有必要了
	assert(pos >= 0 && pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;
}


int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

因为头插、尾插、头删、尾删可以用SeqInsert函数和SeqErase函数来实现，所以原本这四个函数的实现代码就可以不用了，可以直接使用SeqInsert函数和SeqErase函数，即函数的复用。多使用可复用的代码，让程序可维护性更好，更便于调试、测试。

SeqList.c中部分函数复用的版本（简化）

#include"SeqList.h"

void SLInit(SL* ps)
{
	//暴力检查
	assert(ps);
	ps->a = (SLDataType*)malloc(sizeof(SLDataType) * INIT_CAPACITY);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->capacity = INIT_CAPACITY;
	ps->size = 0;
}

void SLDestory(SL* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = 0;
	ps->capacity = 0;
}

void SLPrint(SL* ps)
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		printf("%d ", ps->a[i]);
	}
	printf("\n");
}

void SLCheckCapacity(SL* ps)
{
	assert(ps);
	if (ps->size == ps->capacity)
	{
		SLDataType* pf = NULL;
		pf = (SLDataType*)realloc(ps->a,
			sizeof(SLDataType) * ps->capacity * 2);
		if (pf == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = pf;
		ps->capacity *= 2;
	}
}

void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	//扩容
	SLCheckCapacity(ps);
	SLInsert(ps, ps->size, x);
}

void SLPopBack(SL* ps)
{
	assert(ps);
	//两种判断size是否为0
	//1.size已经为0的时候，断言的方式来暴力提醒非法访问了
	assert(ps->size > 0);
	//2.不提醒，直接返回
	//if (ps->size == 0)
	//{
	//	return;
	//}

	SLErase(ps, ps->size - 1);
}

void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	//扩容
	SLCheckCapacity(ps);
	SLInsert(ps, 0, x);
}

void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);
	SLErase(ps, 0);

}

void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);

	int end = ps->size - 1;
	while (end >= pos)
	{
		ps->a[end + 1] = ps->a[end];
		--end;
	}
	ps->a[pos] = x;
	ps->size++;
}

void SLErase(SL* ps, int pos)
{
	assert(ps);
	//在这里已经间接检查了size是否为0，所以assert(ps->size)就没有必要了
	assert(pos >= 0 && pos < ps->size);
	int begin = pos + 1;
	while (begin < ps->size)
	{
		ps->a[begin - 1] = ps->a[begin];
		++begin;
	}
	ps->size--;
}


int SLFind(SL* ps, SLDataType x)
{
	assert(ps);
	for (int i = 0; i < ps->size; ++i)
	{
		if (ps->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

3.3 Test.c

#include"SeqList.h"
void TestSeqList1()
{
	SL s;
	SLInit(&s);
	SLPushBack(&s, 1);
	SLPushBack(&s, 2);
	SLPushBack(&s, 3);
	SLPushBack(&s, 4);
	SLPushFront(&s, 0);
	SLPrint(&s);
	SLPopFront(&s);
	SLPrint(&s);
	SLPopFront(&s);
	SLPrint(&s);
	SLPopFront(&s);
	SLPrint(&s);
	SLDestory(&s);
}
int main()
{
	TestSeqList1();
	return 0;
}

注意：

  • 头插、头删N个数据的时间复杂度是O(N)
  • 尾插、尾删N个数据的时间复杂度是O(1)
  • 有了SLInsert，就不用再编写头插、尾插函数了，可以复用了，SLErase和头删、尾删同理。（复用见SeqList.c代码
  • 对于顺序表，尾插、尾删是很高效的，但是头插和头删就太低效了，所以头插、头删、中间插入、中间删除等就要使用链表等等了

拓展：

关于realloc
当realloc修改的内存大小比原本malloc（或celloc）创建的大小还要小的时候，将相差的那部分内存的使用权限还给操作系统，理论上来说算作是缩容。但是我们顺序表中一般不用缩容。
原因如下：

  1. 缩容本身是要消耗性能的。
  2. 一般情况下，我们扩容（只要要扩容的空间不是特别大）都是在原来的内存后边再申请空间。缩容后，若再要开辟空间，此时如果后面的空间已经被别的数据给占用了，那么就要重新找一块大的空间来给realloc开辟，这就很消耗性能了。
  3. 对于现在的计算机而言，内存一般用不着节省，没必要缩容来节省那一小块空间。
时间书写
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
数据结构顺序表基本流程
采菊东篱下，Python满乾坤！
11-13 4215
生活中很多事物是有顺序关系的，如班级座位从前到后是按排的顺序，从左到右是按列的顺序，可以很方便的定位到某一个位置，但如果座位是散乱的，就很难定位。 在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。 对于这种需求，最简单的解决方案便是将这样一组元素看成一个序
数据结构顺序表
travel_dream的博客
04-07 2418
1.线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上(内存中)并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2.顺序表 2.1概念及结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。使用顺序表的原因在于，数
【数据结构】顺序表
East-sunrise的博客
08-15 4167
顺序表带你走进数据结构世界🎈
数据结构和算法（顺序表）
sun_xiao_kai的博客
02-01 761
现在看一下，对于整型数据int = 1,2,3,4,5（基本数据类型），对于这部分数据该怎么保存呢？抛弃掉高级数据类型（列表，字典等这些python这些封装好的数据结构），只记得整型、浮点型、字符型等基本数据类型。那么对于int=1,2,3,4,5这部分数据该怎么保存呢？首要的一点是要知道数据存贮的本质是什么？ 内存 计算机的内存是存储数据并直接与CPU打交道的。既然是内存，那就是存储单元了，即组...
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
数据结构实验——顺序表
12-22
数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
注：分为三个内容：顺序表、单链表、运行结果。代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-...
数据结构——用现有链表转换为顺序表
06-26
用链表创建顺序表，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
图解数据结构（使用Python）——链表
12-21
概念：链表（Linked List）是由许多相同数据类型的数据按特定顺序排列而成的线性表，其特点是各个数据在计算机内存中的位置是不连续且随机的。 优点： 数据的插入和删除都比较方便，不需要移动大量的数据（列表在...
严蔚敏《数据结构》源码 顺序表——二叉树
06-08
目前写在了图，之后的内容会在github上持续更新，数据结构系列更新完之后，可能会更新算法的教程（参考屈婉玲版《算法设计与分析》）希望可以帮到各位！！ InitList.cpp------顺序表 LinkList.cpp------链表 ...
数据结构——线性表
02-06
另外还实现了简单单链表、简单顺序线性表、从A链表中删除B和C链表共有的元素、单链表逆置（以整数为例）、将链表中元素按递增排序并删除所选定范围内的元素、求一个新的集合A为A和B的交集（采用单链表作为存储结构）...
数据结构——矩阵.docx
07-11
数据结构——矩阵全文共7页，当前为第1页。数据结构——矩阵全文共7页，当前为第1页。 数据结构——矩阵全文共7页，当前为第1页。 数据结构——矩阵全文共7页，当前为第1页。 软件学院 上机实验报告 课程名称： 数据...
算法和数据结构——左程云.zip
最新发布
01-15
基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和空间复杂度。 算法： 算法设计：研究如何将解决问题的步骤形式化为一系列指令，...
数据结构之顺序表
qq_53822523的博客
05-27 2283
数据结构顺序表之增删查改的最全攻略
数据结构-顺序表
qq_40844674的博客
03-24 2127
Part2 顺序表 1 概念 1.1 线性表 零个或多个数据元素的有限序列。元素之间存在顺序，第一个元素无前驱，最后一个元素无后继，其他元素有且仅有一个前驱和后继。 1.2 顺序表 线性表的顺序存储结构---数组 即顺序表：用一组地址连续的存储单元依次存储线性表的数据元素。 即：逻辑上相邻的数据元素，其物理次序也是相邻的。 2 顺序表实现 2.1 数据元素属性 （1）存储空间的起始地址：数组名 （2）线性表的最大存储容量：数组长度 （3）线性表的当前长度：length 2.2.
Java数据结构——用顺序表编写一个简易通讯录
05-15
好的，下面是用Java顺序表实现简易通讯录的代码： 首先，在Java中需要定义一个类来表示通讯录中的每一个联系人，这个类包含联系人的姓名和电话号码两个属性： ```java public class Contact { private String ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值