【数据结构】实现顺序表的增删查改

最新推荐文章于 2024-05-01 21:00:53 发布
最新推荐文章于 2024-05-01 21:00:53 发布
阅读量866 收藏 1
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51064412/article/details/114259579
版权

文章目录

一.顺序表介绍

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

(1)静态顺序表：使用定长数组存储，适用于确定知道需要存多少数据的场景

#define N 100
typedef int SeqListDataType;
typedef struct SeqList
{
SLDataType array[N]; // 定长数组
size_t size; // 有效数据的个数
}SeqList;

(2)动态顺序表：使用动态开辟的数组存储，可根据需要动态的分配空间大小。

typedef struct SeqList
{
SLDataType* array; // 指向动态开辟的数组
size_t size ; // 有效数据个数
size_t capicity ; // 容量空间的大小
}SeqList;

二.动态顺序表增删查功能实现

现在Seqlist.h里对相关功能的函数，结构体进行声明，和类型的重定义

#pragma once

//C库函数的头文件声明
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

//自定义顺序表元素的类型
typedef int SeqListDateType;

//顺序表的结构体
typedef struct SeqList
{
	SeqListDateType* data;
	size_t size;
	size_t capacity;
}SL;

//基本的增删查改接口
//顺序表的初始化
void SeqListInit(SL* ps);
//顺序表销毁
void SqeListDestory(SL* ps);
//顺序表打印
void SeqListPrint(SL* ps);
//顺序表在pos位置插入x
void SeqListInsert(SL* ps, size_t pos, SeqListDateType x);
//顺序表删除pos位置的值
void SeqListErase(SL* ps, size_t pos);
//顺序表尾插
void SeqListPushBack(SL* ps, SeqListDateType x);
//顺序表尾删
void SeqListPopBack(SL* ps);
//顺序表头插
void SeqListPushFront(SL* ps, SeqListDateType x);
//顺序表头删
void SeqListPopFront(SL* ps);
//顺序表查找(找到了返回下标，找不到返回-1)
int SeqListFind(SL* ps, SeqListDateType x);

（1）顺序表的初始化:对数组开辟4个容量的空间，有效数据为0，容量为4

void SeqListInit(SL* ps)
{
	assert(ps);
	ps->data = (SeqListDateType*)malloc(4 * sizeof(SeqListDateType));
	if (ps->data == NULL)
	{
		printf("申请内存失败\n");
		exit(-1);
	}
	ps->size = 0;
	ps->capacity = 4;
}

（2）对开辟后的空间销毁

void SqeListDestory(SL* ps)
{
    //断言，保证指针的有效性，防止野指针
	assert(ps);
	free(ps->data);
	ps->data = NULL;
}

（3）打印顺序表的内容

void SeqListPrint(SL* ps)
{
    //断言，保证指针的有效性，防止野指针
	assert(ps);
	for (size_t i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->data[i]);
	}
}

（4）检查空间，如果满了，进行原来空间1倍的增容；没满就啥都不干（这个函数只在SeqList.c内部使用，使用static修饰，SeqList.h也不用声明这个函数）

static void CheckCapacity(SL* ps)
{
    //断言，保证指针的有效性，防止野指针
	assert(ps);
	if (ps->size == ps->capacity)
	{
		ps->capacity *= 2;
		ps->data = (SeqListDateType*)realloc(ps->data, ps->capacity * sizeof(SeqListDateType));
		if (ps->data == NULL)
		{
			printf("增容失败\n");
			exit(-1);
		}
	}
}

（5）任意位置（position）插入数据

void SeqListInsert(SL* ps, size_t pos, SeqListDateType x)
{
	//断言，保证指针的有效性，防止野指针，和保证输入的位置正确
	assert(ps&& pos <= ps->size);
	CheckCapacity(ps);//插入数据之前先检查空间是否足够
	//把pos位置后面的数据往后移动
	int end = (int)ps->size - 1;
	while ((int)pos <= end)
	{
		ps->data[end + 1] = ps->data[end];
		end--;
	}
	//在pos上插入数据
	ps->data[pos] = x;
	//插入之后有效数据加一
	ps->size++;
}

（6）任意位置（position）删除数据

void SeqListErase(SL* ps, size_t pos)
{
	//断言，保证指针的有效性，防止野指针，和保证输入的位置正确
	assert(ps&&pos < ps->size);
	//把pos位置后面的数据往前移动
	size_t start = pos;
	while ((int)start <= (int)ps->size - 2)
	{
		ps->data[start] = ps->data[start + 1];
		start++;
	}
	//删除之后有效数据减一
	ps->size--;
}

（7）尾部插入一个数据

void SeqListPushBack(SL* ps, SeqListDateType x)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	CheckCapacity(ps);//插入数据之前先检查空间是否足够
	//直接在最后一个位置插入数据
	ps->data[ps->size] = x;
	//插入之后有效数据加一
	ps->size++;
}

（8）尾部删除一个数据

void SeqListPopBack(SL* ps)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	//直接有效数据减一，不会打印出来最后一个数据
	ps->size--;
}

（9）头部插入一个数据

void SeqListPushFront(SL* ps, SeqListDateType x)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	CheckCapacity(ps);//插入数据之前先检查空间是否足够
	//把原来的所有数据往后移动，腾出第一个位置来
	size_t end = ps->size - 1;
	while ((int)end >= 0)
	{
		ps->data[end + 1] = ps->data[end];
		end--;
	}
	//头插
	ps->data[0] = x;
	//有效数据加一
	ps->size++;
}

（10）头部删除一个数据

void SeqListPopFront(SL* ps)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	//把第二个数据开始所有的数据往前移动
	for (size_t i = 0; i < ps->size - 1; i++)
	{
		ps->data[i] = ps ->data[i + 1];
	}
	//有效数据减一
	ps->size--;
}

（11）查找数据（找到了返回下标，找不到返回-1）

int SeqListFind(SL* ps, SeqListDateType x)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	//根据下标遍历所有数据来查找
	for (size_t i = 0; i < ps->size; i++)
	{
		if (ps->data[i] == x)
		{
			//找到了就返回下标
			return i;
		}
	}
	//没找到就返回-1
	return -1;
}

三.完整代码

ps:完整代码包含在三个文件里
（1）SeqList.h

#pragma once

//C库函数的头文件声明
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

//自定义顺序表元素的类型
typedef int SeqListDateType;

//顺序表的结构体
typedef struct SeqList
{
	SeqListDateType* data;
	size_t size;
	size_t capacity;
}SL;

//基本的增删查改接口
//顺序表的初始化
void SeqListInit(SL* ps);
//顺序表销毁
void SqeListDestory(SL* ps);
//顺序表打印
void SeqListPrint(SL* ps);
//顺序表在pos位置插入x
void SeqListInsert(SL* ps, size_t pos, SeqListDateType x);
//顺序表删除pos位置的值
void SeqListErase(SL* ps, size_t pos);
//顺序表尾插
void SeqListPushBack(SL* ps, SeqListDateType x);
//顺序表尾删
void SeqListPopBack(SL* ps);
//顺序表头插
void SeqListPushFront(SL* ps, SeqListDateType x);
//顺序表头删
void SeqListPopFront(SL* ps);
//顺序表查找(找到了返回下标，找不到返回-1)
int SeqListFind(SL* ps, SeqListDateType x);

（2）SeqList.c

#include"SeqList.h"

void SeqListInit(SL* ps)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	ps->data = (SeqListDateType*)malloc(4 * sizeof(SeqListDateType));
	if (ps->data == NULL)
	{
		printf("申请内存失败\n");
		exit(-1);
	}
	ps->size = 0;
	ps->capacity = 4;
}

void SqeListDestory(SL* ps)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	free(ps->data);
	ps->data = NULL;
}

void SeqListPrint(SL* ps)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	for (size_t i = 0; i < ps->size; i++)
	{
		printf("%d ", ps->data[i]);
	}
}

//检查空间，如果满了，进行增容
static void CheckCapacity(SL* ps)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	if (ps->size == ps->capacity)
	{
		ps->capacity *= 2;
		ps->data = (SeqListDateType*)realloc(ps->data, ps->capacity * sizeof(SeqListDateType));
		if (ps->data == NULL)
		{
			printf("增容失败\n");
			exit(-1);
		}
	}
}

void SeqListInsert(SL* ps, size_t pos, SeqListDateType x)
{
	//断言，保证指针的有效性，防止野指针，和保证输入的位置正确
	assert(ps&& pos <= ps->size);
	CheckCapacity(ps);//插入数据之前先检查空间是否足够
	//把pos位置后面的数据往后移动
	int end = (int)ps->size - 1;
	while ((int)pos <= end)
	{
		ps->data[end + 1] = ps->data[end];
		end--;
	}
	//在pos上插入数据
	ps->data[pos] = x;
	//插入之后有效数据加一
	ps->size++;
}

void SeqListErase(SL* ps, size_t pos)
{
	//断言，保证指针的有效性，防止野指针，和保证输入的位置正确
	assert(ps&&pos < ps->size);
	//把pos位置后面的数据往前移动
	size_t start = pos;
	while ((int)start <= (int)ps->size - 2)
	{
		ps->data[start] = ps->data[start + 1];
		start++;
	}
	//删除之后有效数据减一
	ps->size--;
}

void SeqListPushBack(SL* ps, SeqListDateType x)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	CheckCapacity(ps);//插入数据之前先检查空间是否足够
	//直接在最后一个位置插入数据
	ps->data[ps->size] = x;
	//插入之后有效数据加一
	ps->size++;
}

void SeqListPopBack(SL* ps)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	//直接有效数据减一，不会打印出来最后一个数据
	ps->size--;
}

void SeqListPushFront(SL* ps, SeqListDateType x)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	CheckCapacity(ps);//插入数据之前先检查空间是否足够
	//把原来的所有数据往后移动，腾出第一个位置来
	size_t end = ps->size - 1;
	while ((int)end >= 0)
	{
		ps->data[end + 1] = ps->data[end];
		end--;
	}
	//头插
	ps->data[0] = x;
	//有效数据加一
	ps->size++;
}

void SeqListPopFront(SL* ps)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	//把第二个数据开始所有的数据往前移动
	for (size_t i = 0; i < ps->size - 1; i++)
	{
		ps->data[i] = ps ->data[i + 1];
	}
	//有效数据减一
	ps->size--;
}

int SeqListFind(SL* ps, SeqListDateType x)
{
	//断言，保证指针的有效性，防止野指针
	assert(ps);
	//根据下标遍历所有数据来查找
	for (size_t i = 0; i < ps->size; i++)
	{
		if (ps->data[i] == x)
		{
			//找到了就返回下标
			return i;
		}
	}
	//没找到就返回-1
	return -1;
}

（3）test.c(对顺序表进行测试)

#include"SeqList.h"

int main()
{
	//定义一个顺序表变量s
	SL s = { 0 };
	//顺序表接口功能的测试
	SeqListInit(&s);
	SeqListInsert(&s,0,1);
	SeqListInsert(&s, 1, 2);
	SeqListInsert(&s, 2, 3);
	SeqListErase(&s, 1);
	SeqListPrint(&s);
	printf("\n");
	return 0;
}

四.动态顺序表总结

1.可动态增长的数组
2.数据在数组中存储时必须是连续的

缺点：
1.中间或头部的插入删除很慢，需要挪动数据。时间复杂度为O（N）
2.空间不够时，增容会有一定的时间消耗和空间浪费

优点：
1.可以随机访问数据
2.cpu在缓存中拿数据时命中率高

Luojj_2020
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表的实现插入删除
HiMark
03-28 4843
实现基于静态数组的顺序表的以下基本操作: 1. 初始化 2. 尾插 3. 尾删 4. 头插 5. 头删 6. 读任意位置元素 7. 修改任意位置元素 8. 查找指定元素值的下标 9. 在任意位置插入元素 10.删除顺序表中指定的值, 如果存在重复元素, 只删除第一个 11.删除顺序表中所有的指定的值, 另外要实现一个时间复杂度为 O(N) 的优化版本 12
数据结构C语言实现顺序表——增删查改操作实现详解
weixin_58401910的博客
09-21 3119
一段物理地址连续的存储单元依次存储数据元素的线性结构，其实就是数组，要求存储的数据是依次连续存储。
数据结构C语言版 —— 顺序表增删改查实现
爱敲代码的三毛的博客
12-14 1411
顺序表的插入和删除时间复杂度为O(N)O(N)O(N)顺序表的扩容使用的是realloc，如果后面的空间不够就会重新开辟新的空间，再把数据拷贝到新的空间，这样就会有一定的额性能消耗顺序表存在着一定的资源浪费，比如当前顺序表的容量为200，当放满之后再插入10个元素，就会进行2倍扩容到400，此时就浪费了190个数据空间。我们发现顺序表存在着一定缺陷，如果想不那么浪费空间就想着扩容扩少一点，但扩容小了如果有大量数据插入又会存着不断扩容的情况，那么又会有着性能的消耗。
顺序表的增删查改的实现以及讲解（一篇包懂）
最新发布
shylyly_的博客
05-01 906
1：断言:，不仅是对接收到的结构体指针进行断言，还是对pos的值进行断言，pos应该处于0~size-1之间，也就是＞=0，＜size，超过这个两端，就越界了。1：断言:，不仅是对接收到的结构体指针进行断言，还是对pos的值进行断言，pos应该处于0~size-1之间，也就是＞=0，＜size，超过这个两端，就越界了。1：断言:，不仅是对接收到的结构体指针进行断言，还是对pos的值进行断言，pos应该处于0~size之间，也就是＞=0，＜=size，超过这个两端，就越界了。capacity已经在。
数据结构顺序表，实现增删改查
小钱努力学C的博客
07-17 548
Seqlist *Request_space(void) //创建空间int empty_list(Seqlist *list) //判断顺序表长度是否为空-1:0;int full_list(Seqlist *list) //判断顺序表长度是否为满-1:0;int insert_rear(datatype value,Seqlist *list) //实现尾插return -1;return 0;void Output(Seqlist *list) //实现输出。
Educoder头歌数据结构顺序表及其应用
qq_50848214的博客
11-05 1万+
头歌实践平台答案 数据结构-顺序表及其应用 第1关：顺序表的实现之查找功能 /************************************************************* 顺序表的实现之查找功能 实现文件 更新于2020年4月13日 **************************************************************/ void SL_GetAt(SqList L, int i, ElemType &e)
数据结构与算法之顺序表的增删查改
07-03
数据结构与算法之顺序表的增删查改
顺序表的增删查改以及拼接操作SqList.cpp
11-28
顺序表的增删查改以及拼接操作
php线性表顺序存储实现代码(增删查改)
12-18
php /* *文件名：linearList.php * 功能：数据结构线性表的顺序存储实现 * author:黎锦焕 * @copyright:www.drw1314.com */ class linearList { private $arr; private $length; const MAXSIZE=100; /* *构造函数，...
数据结构—顺序表实现(C语言版本)
08-04
顺序表的增删查改功能全实现(C语言版本)。 可以作为模板实现高校要求的各种程序设计。
顺序表实现学生学号姓名成绩的增删查改
12-25
实习二、线性表（顺序存储）及其应用（分四个实验） 实习目的：掌握顺序表的建立及基本操作。 问题：建立一个顺序表，表中元素为学生，每个学生信息包含姓名、学号和成绩三部分，对该表实现：① 输出、② 插入、③ 删除、④ 查找功能，并计算出平均成绩和总成绩
顺序表的增删查改（C语言实现）
gangber的博客
07-21 278
"common.h" #ifndef _COMMON_H_ #define _COMMON_H_ #include <stdio.h> #include <stdlib.h> #include <windows.h> #include <assert.h> #include <stdbool.h> #include <vld.h>//检查内存泄漏 #pragma warning(disable:4996) #define Elem
C语言实现顺序表增删查改操作
春天的熊的博客
04-10 7932
C语言实现顺序表增删查改操作线性表是最常用且最简单的一种数据结构。线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。结构如下图图片来自百度 为了描述顺序表，我们声明一个结构，如下： #define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量 #define LIST_INCREMENT 10 //线性表存储空间的分配增量typedef int Elem
Educoder头歌数据结构链表及其应用
热门推荐
qq_50848214的博客
11-05 1万+
头歌实践平台答案educoder 数据结构-链表及其应用 第1关：链表的实现之查找功能 /************************************************************* 链表的实现之查找功能 实现文件 更新于2020年4月21日 **************************************************************/ void LL_GetAt(LinkList L, int i, ElemType &amp
数据结构 线性表 插入 删除
mmmm0303的博客
04-22 1万+
数据结构线性表的插入，删除 任务描述 本关任务：实现 step1/Seqlist.cpp 中的SL_InsAt、SL_DelAt和SL_DelValue三个操作函数，以实现线性表中数据的插入、删除与查找等功能。 相关知识) 线性表是最基本、最简单、也是最常用的一种数据结构。线性表结构中，数据元素之间通过一对一首尾相接的方式连接起来。具体实现时，线性表可以采用不同的存储策略。下面给出了一种基于顺序存...
数据结构顺序表的“增删改查”功能实现
程序袁的博客
08-01 6256
今天完成的是顺序表的简单功能实现 #include #define maxSize 100 using namespace std; typedef struct{         int data[maxSize];//data数组用来放数据         int length;//length是数组的长度 }Sqlist; //建立一个结构体用来表示顺
顺序表实现增删查改
weixin_41249411的博客
10-12 1400
本文摘要： 1.顺序表的概念 2.顺序表结构的定义 3.动态顺序表的操作实现   顺序表的概念 顺序表是一种数据结构，是数据的存储方式。 顺序表是改善了数组的缺点，相对增加了灵活性，使用户能够实现增删查改的操作。 顺序表分为静态顺序表和动态顺序表。                            顺序表的定义 //静态顺序表 #define N 100 typede...
顺序表的实现及增删查改
v_yang_guang_v的专栏
04-04 508
#include using namespace std; #define InitSpace 100 #define IncSpace 10 typedef int datatype; //定义结构体 typedef struct seqlist{ datatype *elem; int listlength; int length; }sequence_list; //初始
数据结构1——顺序表的增删改查排序
weixin_43864170的博客
12-10 544
数据结构1——顺序表的增删改查排序 数据结构的第一课就是顺序表的增删改查排序问题。顺序表相对于链表来说是一种相对简单的线性结构，其中涉及到了数据的添加，删除，查找，排序，遍历，和销毁。 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #define Max 1024 typedef int elem...
顺序表增删查改的时间自由度
04-04
顺序表的增、删、查、改操作的时间复杂度取决于数据规模和操作的位置。 增操作：在顺序表的末尾进行插入操作的...因此，顺序表的增删查改操作的时间自由度相对较低，操作的时间复杂度取决于具体的操作位置和数据规模。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值