【数据结构】--顺序表的实现

已于 2024-04-16 08:05:53 修改
阅读量1k 收藏 16
点赞数 39
分类专栏： 数据结构 文章标签： 数据结构
于 2024-04-15 13:24:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78009847/article/details/137638546
版权

一、顺序表的概念

什么是顺序表？顺序表（SeqList）是线性表中的一类。而线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、字符串、栈、队列... 注意：线性表在逻辑上是线性结构，也就是说是一条连续的直线。但在物理结构上不一定是连续的。（这里很好理解，例如有10个人在买蜜雪冰城，在逻辑上应该是10个人按照先后顺序排成一队一个一个买，突然这10个人中的一个人的朋友也要买蜜雪冰城，但是他不想排队，他就站在他朋友的旁边一起买。这就是在物理上不一定连续。）

而顺序表是用一组地址连续的存储单元依次存储线性表中的数据元素。顺序表在逻辑结构是线性的结构，在物理结构上是连续的。它的底层是基于数组来实现的，所以顺序表的实现其实是在数组上完成数据的增删查改。

二、顺序表的分类

1、静态顺序表   

 定义：使用定长数组存储数据 

//静态顺序表
typedef int SLDataType;
#define N 6
typedef struct SeqList
{
    SLDataTyppe arr[N];//定长数组
    int size;//有效数据个数
}SL;

2、动态顺序表（推荐使用）

 定义：按需申请容量大小

//动态顺序表

//顺序表不仅可以插入整形数据，还可以插入浮点型，char型等等
//所以我们给int重新定义一个名字SLDataType,后面如果想要换数据类型，直接更改typedef后面的int就好了
typedef int SLDataType;

typedef struct SeqList
{
    SLDataType* arr;//一级指针指向的动态开辟的数组
    int size;//有效数据个数
    int capacity;//数组的容量大小
}SL;

在这里我推荐使用动态顺序表。静态顺序表如果空间给少了不够用，给多了会造成空间浪费。动态顺序表可以根据需要的多少来调整顺序表的大小。 

三、动态顺序表的实现

1、定义一个动态顺序表   

//动态顺序表
typedef int SLDataType;

typedef struct SeqList
{
    SLDataType* arr;//一级指针指向的动态开辟的数组
    int size;//有效数据个数
    int capacity;//数组的容量大小
}SL;

2、对动态顺序表进行初始化

//初始化顺序表
void SeqListInit(SL* ps)
{
	assert(ps);//断言ps指针不能是空指针
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

3、对顺序表进行扩容 

                                扩容思路：

（1）判断顺序表的空间容量是否足够？当顺序表的数据个数==空间容量时表示顺序表的空间容量已经满了，需要进行扩容。

（2）用三目表达式来判断，如果顺序表的空间容量为0，则先给空间容量为4（这个数值是随便设置）；如果空间容量不为0，则让空间容量以2倍的数量进行增加。（这样可以在扩容的同时减少空间的浪费）

（3）用realloc进行动态空间的扩容。

（4）检查realloc是否扩容成功并用一个临时指针temp来接收，若temp不为空，则将temp赋值给ps->arr,并将新的空间容量newcapacity赋值给capacity。

//扩容
void SLCheckCapacity(SL* ps)
{
	assert(ps);
	if (ps->capacity == ps->size)
	{
		//扩容
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* temp = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
		if (temp == NULL)
		{
			perror("realloc fail!");
			exit(1);//直接退出程序不在执行
		}
		ps->arr = temp;
		ps->capacity = newcapacity;
	}
}

4、打印顺序表

顺序表的底层是数组，所以打印顺序表就相当于打印数组，这里非常简单所以直接上代码

//打印顺序表
void SeqListPrint(SL* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

5、顺序表尾插数据

顺序表尾插就是在数组里size这个位置插入数据，所以需要注意的当插入完数据之后不要忘了size++。

81434d9938544cd2bbdac5774ae0909b.png

例如这里尾插一个4，在ps->arr[ps->size]这个位置插入完数据之后，ps->size要往后移动一位。

//尾插
void SeqListPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	//判断是否需要扩容
	SLCheckCapacity(ps);
	ps->arr[ps->size] = x;
	ps->size++;
}

6、顺序表头插数据

顺序表头插其实就是在数组的下标为0的位置插入数据，所以我们需要先把顺序表里面的数据从后往前依次向后移动一位，把下标为0的位置空出来在插入数据。

4247bc8136b2482abd88bb5528e84e65.png

例如我想头插一个5，所以我需要先把1,2,3,4四个数据从后往前依次往后移动一位，然后插入5。

//头插
void SeqListPushFront(SL* ps,SLDataType x)
{
	assert(ps);
	//判断是否需要扩容
	SLCheckCapacity(ps);
	int i = 0;
	for (i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

7、顺序表尾删数据

顺序表尾删数据就非常简单了，只需要让ps->size--,size向前移动一位就好了。但需要注意的一点是必须要判断一下ps->size是否大于0，因为顺序表里必须要有数据才能够做删除操作。这里直接上代码。

//尾删
void SeqListPopBack(SL* ps)
{
	assert(ps);
	//这里有两种方法来判断ps->size是否>0
	//第一种方法比较温柔
	//if (ps->size == 0)
	//{
		//return;
	//}
	//第二种方法比较简单粗暴
	assert(ps->size > 0);
	ps->size--;
}

8、顺序表头删数据

头删操作也非常的easy，头删只需要把顺序表里从下标为1的数据开始依次往前移动一位，同时也要判断ps->size是否大于0，以及删除一个数据要让ps->size--。

//头删
void SeqListPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);
	int i = 0;
	for (i = 1; i < ps->size; i++)
	{
		ps->arr[i - 1] = ps->arr[i];
	}
	ps->size--;
}

9、顺序表查找数据

顺序表查找就是通过遍历数组来比较数组里的数据与已知要查找的数据是否相等。若相等，则返回数组下标，若不相等，则返回-1表示所查找的数据不存在。

//查找顺序表
int SeqListFind(SL* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

10、在指定位置（pos）插入数据

在指定位置插入数据，首先我们需要通过SeqListFind函数接口来得到需要插入数据的位置下标，接着我们要把从pos到ps->size-1位置上的数据从后往前向后移动一位，把pos 位置空出来，最后在pos位置插入数据。

45f2224c3b85459987b9ef13caac9900.png

8b71ecb423d7484c962d9c90da171aa5.png

例如，我想要在2这个位置插入100，首先把2,3,4三个数据从后往前依次向后移动一位，然后在pos位置插入100。

//指定位置插入数据
void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	//pos必须是有效的数据下标
	assert(pos >= 0 && pos < ps->size);
	//判断是否需要扩容
	SLCheckCapacity(ps);
	int i = 0;
	for (i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

11、在指定位置（pos）删除数据

这里就很简单了，只需要让pos位置之后的数据整体向前移动一位就好了。

//指定位置删除数据
void SeqListErase(SL* ps, int pos)
{
	assert(ps);
	//pos必须是有效的数据下标
	assert(pos >= 0 && pos < ps->size);
	int i = 0;
	for (i = pos; i < ps->size; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

12、销毁顺序表

//销毁顺序表
void SeqListDestroy(SL* ps)
{
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

四、完整代码

SeqList.h

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

typedef int SLDataType;

typedef struct SeqList
{
	SLDataType* arr;
	int size;
	int capacity;
}SL;

//初始化顺序表
void SeqListInit(SL* ps);
//销毁顺序表
void SeqListDestroy(SL* ps);
//扩容
void SLCheckCapacity(SL* ps);
//打印顺序表
void SeqListPrint(SL* ps);
//尾插
void SeqListPushBack(SL* ps, SLDataType x);
//头插
void SeqListPushFront(SL* ps);
//尾删
void SeqListPopBack(SL* ps);
//头删
void SeqListPopFront(SL* ps);
//查找顺序表
int SeqListFind(SL* ps, SLDataType x);
//指定位置之前插入数据
void SeqListInsert(SL* ps, int pos, SLDataType x);
//指定位置删除数据
void SeqListErase(SL* ps, int pos);

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"

//初始化顺序表
void SeqListInit(SL* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

//销毁顺序表
void SeqListDestroy(SL* ps)
{
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}

//扩容
void SLCheckCapacity(SL* ps)
{
	assert(ps);
	if (ps->capacity == ps->size)
	{
		//扩容
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* temp = (SLDataType*)realloc(ps->arr, newcapacity * sizeof(SLDataType));
		if (temp == NULL)
		{
			perror("realloc fail!");
			exit(1);//直接退出程序不在执行
		}
		ps->arr = temp;
		ps->capacity = newcapacity;
	}
}

//打印顺序表
void SeqListPrint(SL* ps)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->arr[i]);
	}
	printf("\n");
}

//尾插
void SeqListPushBack(SL* ps, SLDataType x)
{
	assert(ps);
	//判断是否需要扩容
	SLCheckCapacity(ps);
	ps->arr[ps->size] = x;
	ps->size++;
}

//头插
void SeqListPushFront(SL* ps,SLDataType x)
{
	assert(ps);
	//判断是否需要扩容
	SLCheckCapacity(ps);
	int i = 0;
	for (i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

//尾删
void SeqListPopBack(SL* ps)
{
	assert(ps);
	//这里有两种方法来判断ps->size是否>0
	//第一种方法比较温柔
	//if (ps->size == 0)
	//{
		//return;
	//}
	//第二种方法比较简单粗暴
	assert(ps->size > 0);
	ps->size--;
}

//头删
void SeqListPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size > 0);
	int i = 0;
	for (i = 1; i < ps->size; i++)
	{
		ps->arr[i - 1] = ps->arr[i];
	}
	ps->size--;
}

//查找顺序表
int SeqListFind(SL* ps, SLDataType x)
{
	assert(ps);
	int i = 0;
	for (i = 0; i < ps->size; i++)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

//指定位置插入数据
void SeqListInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	//pos必须是有效的数据下标
	assert(pos >= 0 && pos < ps->size);
	//判断是否需要扩容
	SLCheckCapacity(ps);
	int i = 0;
	for (i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

//指定位置删除数据
void SeqListErase(SL* ps, int pos)
{
	assert(ps);
	//pos必须是有效的数据下标
	assert(pos >= 0 && pos < ps->size);
	int i = 0;
	for (i = pos; i < ps->size; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

test.c

测试文件可以自己写，这里仅供参考。

#define _CRT_SECURE_NO_WARNINGS 1
#include"SeqList.h"

void test()
{
	SL s;
	SeqListInit(&s);
	SeqListPushBack(&s, 1);
	SeqListPushBack(&s, 2);
	SeqListPushBack(&s, 3);
	SeqListPushBack(&s, 4);
	SeqListPrint(&s);
	//SeqListPushFront(&s, 5);
	//SeqListPrint(&s);
	//SeqListPopBack(&s);
	//SeqListPrint(&s);
	//SeqListPopFront(&s);
	//SeqListPopFront(&s);
	//SeqListPopFront(&s);
	//SeqListPopFront(&s);
	//SeqListPopFront(&s);
	//SeqListPrint(&s);
	int find = SeqListFind(&s, 2);
	if (find < 0)
	{
		printf("所查找的数据不存在！\n");
	}
	else
	{
		printf("所查找的数据存在，该数据所在位置下标为%d\n", find);
	}
	SeqListInsert(&s, find, 100);
	SeqListPrint(&s);
	SeqListErase(&s, find);
	SeqListPrint(&s);
}

int main()
{
	test();
	return 0;
}

这是关于数据结构的第一篇博客，后期我会持续更新数据结构以及C语言的相关内容。欢迎大家在评论区相互讨论以及指出我的不足，我会在后面的文章中参考大家的建议来写出更好的博客。

感谢大家点赞+关注，来跟着我一起学习吧！

 

 

Alan编程
关注
  • 39
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
顺序表的实现超详细
川子767的博客
02-24 1343
一文带你学会顺序表的基本实现（超详细）
【数据结构】顺序表实现超详解（保姆级教程）
~
10-15 2180
目录 ​ 前言 顺序表 接口实现 各项功能 接口详解 顺序表初始化 顺序表释放 顺序表展示 顺序表容量检查 顺序表数据尾插 顺序表数据头插 顺序表数据前删 顺序表数据尾删 顺序表数据查找 顺序表指定位置插入数据 顺序表指定位置删除数据 前言 本章主要讲解： 顺序表以及顺序表的接口实现 注：保姆级教程，相信你一定会的~ 顺序表 顺序表是线性标的一种 概念： 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储...
【数据结构】顺序表的实现——超级无敌详细
qq_59702185的博客
08-07 2019
在当我们每想插入一个数据的时候，我们都要对顺序表进行判断，容量 capacity 是否和 size 相等，如果相等的话，那么，顺序表的空间就不够我们进行插入数据了。当然我们不能需要插入一个数据就开辟一个数据的大小，这样的话，付出的代价很大，我们可以每次增容 2 倍的capacity大小的容量，或者4倍，2倍是比较好的了。在我们想把顺表表最后一个数据删除时，不能直接赋为0，第一，我们不知道SLDataType到底是什么数据类型，第二，顺序表的最后一个数据有可能就是0，没有意义。遍历一遍顺序表，打印顺序表。..
数据结构——顺序表的实现
冯同学的博客
11-14 1620
文章目录一、什么是线性表？二、什么是顺序表三、顺序表的实现1.顺序表的接口2.每个接口的实现3.测试程序总结 一、什么是线性表？ 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 二、什么是顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线.
【 数据结构 】顺序表的实现 - 详解（C语言版）
上上谦. 的博客
03-13 8052
目录 前言 线性表： ​ 顺序表： 概念及结构： 顺序表的实现： 头文件：SeqList.h realloc函数讲解： 具体函数的实现：SeqList.c 顺序表的初始化： 顺序表的打印： 容量的检查： 顺序表的尾插： 顺序表的尾删： 顺序表的头插： 顺序表的头删： 在顺序表的指定位置插入数据： 在顺序表的指定位置删除数据： 顺序表的查找： 顺序表的修改： 顺序表的销毁： 数组越界的检查： 前言 简单用C语言来描述数据结构中的顺序表......
【数据结构】顺序表(线性表)的实现
m0_63198468的博客
12-30 1448
本文详细讲述了顺序表的各种接口，里面配有图片能够清晰明了，通俗易懂。
数据结构之【顺序表的实现（详解）】
cls的博客
10-06 4421
线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结 构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在**逻辑上是线性结构，也就说是连续的一条直线。**但是在物理结构上并不一定是连续的，线性表在物 理上存储时，通常以数组和链式结构的形式存储。 顺序表 本质就是一个数组，但它是动态增长的，并且要求里面存储的数据必须是从左往右连续的。 顺序表的物理结构和逻辑结构是一致的都是连续的。 顺序表存在着一定的缺陷： 1.0 动态增容存在性能消
顺序表实现
weixin_56810796的博客
11-03 374
数据结构之顺序表实现
顺序表的实现
weixin_53316121的博客
03-13 2699
目录 1.顺序表的概念 2.静态顺序表 分析： 3.动态顺序表 分析： 4.顺序表初始化 5.顺序表尾部操作 5.1尾插 空间检查函数实现 分析： 5.2尾删 分析： 6.顺序表的头部操作 6.1头插 分析： 6.2头删 分析： 7.固定位置操作 7.1固定位置插入 分析： 7.2固定位置删除 分析： 8.查找及打印 9.销毁顺序表 10.我的菜单及主函数 直接上代码： 1.顺序表的概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素...
数据结构 | 顺序表的基本实现
最新发布
m0_68732914的博客
07-24 513
最近刚在学习《数据结构与算法》，单纯地跟课、看书觉得并不能很好的掌握好这些知识点，所以决定尝试将学习的知识点归纳总结，也将其进行代码实现，强化对知识点的理解。即作为笔记、实践，又作为我的思路分享。因为初学，难免有不正确、不恰当之处，敬请指正！
简单顺序表实现
行走江湖的少侠哥
06-14 463
#include #include #define MAX_LENGTH 20 typedef struct { char name[20]; double price; }BOOK; typedef struct { BOOK *list; int length; }Sqlist; int InitList(Sqlist *); //初始化顺序表 void PrintLis
【数据结构】实现动态顺序表及详细讲解
Eraser的博客
05-04 631
数据结构的常见线性表，分别是顺序表，链表，栈，队列 本篇给大家带来动态顺序表的实现和讲解
数据结构（一）——顺序表（C语言实现）
热门推荐
flueky的专栏
09-30 5万+
顺序表的简单实现
顺序表（C语言实现）
trqii_的博客
04-26 4441
顺序表 文章目录顺序表一、**顺序表的基本概念**二、动态顺序表的具体实现1. 顺序表初始化2. 顺序表尾插3. 顺序表头插4. 顺序表尾删5. 顺序表头删6. 顺序表任意位置插入7. 顺序表任意位置删除8. 顺序表查找9. 顺序表修改10. 顺序表打印11. 顺序表销毁三、完整代码 一、顺序表的基本概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表分为以下二类： 1.静态顺序表：使用定长数组存储元素。 #define N
数据结构与算法——顺序表的实现及原理
m0_62179366的博客
05-02 4088
目录 一、顺序表的原理 1.什么是顺序表？ 2.什么是线性表 3.顺序表与链表的区别 二、顺序表的实现 1.顺序表的初始化 顺序表的定义: 顺序表的初始化 2.顺序表数据在尾部插入 3.顺序表数据在头部插入 4.顺序表数据在尾部的删除 5.顺序表数据在头部的删除 6.顺序表数据在任意位置插入 7.顺序表数据在任意位置删除 8.顺序表元素的查找 9.顺序表元素的修改 10.顺序表元素的打印 11.顺序表的销毁 总结 一、顺序表的原理 1.什么是顺序表？...
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值