【数据结构】顺序表的概念和实现【完整版】

已于 2023-10-12 18:32:51 修改
阅读量445 收藏 6
点赞数 2
分类专栏： 【数据结构】知识篇+代码讲解 文章标签： 数据结构 算法 c语言
于 2023-04-01 15:59:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74044018/article/details/129888871
版权

目录​​​​​​​

一、简述：

二、顺序表的概念

三、顺序表的创建

一、简述：​​​​​​​

顺序表的创建和功能实现（插入，删除，排序等等）和通讯录的实现十分相似，换言之，你会通讯录了，顺序表就是小菜一碟，所以不知道通讯录的实现的话，可以先看一下我写的通讯录的实现过程，这个顺序表只是在通讯录的逻辑上稍加修改就实现了，可以说顺序表是通讯录的副本

我们分3个文件：

seqlist.h文件放——头文件的包含和函数声明

seqlist.c文件放——函数的定义和实现

test.c文件——用来测试写的顺序表的相关逻辑

而且这个程序不建议先写菜单，因为写菜单后你调试麻烦，你每次都需要选择菜单的选项，才能往下调试，所以菜单的实现可以放在最后，并且调试时断点可以移动，但是已经调试的代码不能恢复到没执行的状态，什么时候用？比如我们动态开辟内存成功了，我就想看看开辟没成功的时候，我们就可以拖动断点，看看开辟失败程序是怎么走的

二、顺序表的概念

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。换句话说，顺序表就是数组，但是在数组的基础上，他还要求数据是连续存储的，不能跳跃间隔，即比如a是个数组，存a[5] =0,然后再存a[9] =0这对数组来说是可以的，但对于顺序表，你只能在存完a[5] =0后，存a[6] = 0。

三、顺序表的创建

分为静态顺序表和动态顺序表，但是静态顺序表大小有些固定，所以我们用动态开辟内存函数来创建动态顺序表

//静态版本

//N给小了不够用，给大了会浪费

#define N 10000
typedef int SLDataType;

//静态顺序表
typedef struct SeqList
{
    SLDataType a[N];
    int sz;//数组中存储了多少个数据
}SL;
//动态版本

//和通讯录中通讯录的结构体创建十分相似

#include<stdlib.h>

typedef int SLDataType;

//动态顺序表
typedef struct SeqList
{
    SLDataType* a;
    int sz;//当前顺序表存的有效数据的个数
    int capacity;//当前顺序表的最大容量的个数
}SL;

接下来是函数的相关实现细节，这里说的函数也可以叫做接口函数，接口函数就是某个模块写了主要给其他模块用的函数

1、初始化

//顺序表初始化的实现
void SeqListInit(SL* pc)
{
	pc->a = NULL;
	pc->sz = pc->capacity = 0;//连续赋值
}

2、尾插数据和检查容量

增加数据就要考虑顺序表容量是否够。从顺序表结尾插入数据也属于添加数据，所以要考虑这个顺序表的容量问题，因为我是动态开辟的，先写一个检查容量函数CheckCapacity

有必要说的一点是：越界并不会报错，而是在free释放内存的时候会报错

void CheckCapacity(SL* pc)
{
	if (pc->sz == pc->capacity)
	{
		int newcapacity = pc->capacity == 0 ? 4 : pc->capacity * 2;
		//因为==的优先级高于?: 所以先判断是否容量为0
		//这个操作的成功性在于了解运算符的优先级性
		SLDataType* ptr = (SLDataType*)realloc(pc->a, newcapacity * sizeof(SLDataType));
		if (ptr != NULL)
		{
			pc->a = ptr;
			pc->capacity = newcapacity;
		}
		else
		{
			printf("realloc fail\n");
			exit(-1);
			//开辟都失败了，这个程序就没必要往下走了
			//直接一个exit，终止程序
		}
	}
}
//顺序表尾插数据的实现
void SeqListPushBack(SL* pc, SLDataType x)
{
	//先检查容量，不够就进行扩容
	CheckCapacity(pc);
	pc->a[pc->sz] = x;
	pc->sz++;
}

3、打印顺序表数据的函数

这个操作很简单，我们只需要遍历到当前顺序表有效数据个数(sz)，打印即可

//顺序表打印数据的函数的实现
void SeqListPrint(SL* pc)
{
	int i = 0;
	for (i = 0; i < pc->sz; i++)
	{
		printf("%d ", pc->a[i]);
	}
	printf("\n");
}

​​​​​​​4、尾删数据

//顺序表尾删数据的实现
void SeqListPopBack(SL* pc)
{
//删除的前提是顺序表有元素
//assert条件为真，往下执行，为假，直接程序报错
//这是一个比较粗暴的方式，也可以用if条件判断
//assert记得引头文件
	assert(pc->sz > 0);
	pc->sz--;
}

5、头插数据

//顺序表头插数据的函数实现
void SeqListPushFront(SL* pc,SLDataType x)
{
	CheckCapacity(pc);
	//挪动数据
	int end = pc->sz - 1;
	while (end >= 0)
	{
		pc->a[end + 1] = pc->a[end];
		end--;
	}
	pc->a[0] = x;
	pc->sz++;
}

 6、头删数据

//顺序表头删数据的函数实现
void SeqListPopFront(SL* pc)
{
	assert(pc->sz > 0);
	//挪动数据
	int begin = 0;
	while (begin < pc->sz-1)
	{
		pc->a[begin] = pc->a[begin + 1];
		begin++;
	}
	pc->sz--;
}

7、查找顺序表元素

如果找到了这个元素返回这个元素对应的下标，没找到则返回-1

//查找顺序表中数据的函数实现
//规定找到范围数组元素下标
//没找到返回-1
int SeqListFind(SL* pc, SLDataType x)
{
	int i = 0;
	for (i = 0; i < pc->sz; i++)
	{
		if (pc->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

8、顺序表的指定位置插入

这个函数你需要传你想在哪个位置，插入什么元素，这个位置指的是数组的元素下标，指定位置插入，那么你指定的这个元素下标肯定不能越界，所以先要判断一下并且还要考虑容量问题

//顺序表中插入指定位置(数组下标为pos)的数据的函数
void SeqListInsert(SL* pc,int pos,SLDataType x)
{	//温柔的处理方式
	//插入位置的检查，不能越界
	//if (pos > pc->sz || pos < 0)
	//{
	//	//这里为什么不用perror直接打印动态开辟的错误信息?
	//	//因为perror是调用c语言的一些库函数失败的时候去打印的
	//	//他会打印库函数调用失败的原因，比如main,fopen函数等
	//	printf("pos invalid\n");
	//	//这里不用perror是因为pos可能是因为传参失败
	//	//不是库函数调用失败问题，所以不用
	//	return;
	//}
	//粗暴的处理方式
	assert(pos <= pc->sz && pos >= 0);
	CheckCapacity(pc);
	int end = pc->sz;
	while (end > pos)
	{
		pc->a[end] = pc->a[end-1];
		end--;
	}
	pc->a[pos] = x;
	pc->sz++;
}

9​​​​​​​、顺序表中删除指定位置的数据

这个函数你需要传你想在哪个位置，删除什么元素，这个位置指的是数组的元素下标，指定位置删除，那么你指定的这个元素下标肯定不能越界，所以先要判断一下这个元素是否存在，我给定的范围是否越界

//顺序表中删除指定位置的数据的函数
void SeqListErase(SL* pc, int pos)
{
	assert(pos >= 0 && pos < pc->sz);
	int begin = pos;
	while (begin < pc->sz-1)
	{
		pc->a[begin] = pc->a[begin + 1];
		begin++;
	}
	pc->sz--;
}

​​​​​​​10、销毁顺序表

销毁其实就是因为动态开辟的内存，需要手动返还给操作系统，不然会导致内存泄漏的问题

//销毁顺序表的函数实现
void SeqListDestroy(SL* pc)
{
	free(pc->a);
	pc->a = NULL;
	pc->capacity = 0;
	pc->sz = 0;
}

 最后，源码如下，相关实现逻辑均在代码的注释中！

test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"
void menu()
{
	printf("************************\n");
	printf("*** 1、头插   2、头删 ***\n");
	printf("*** 3、尾插   4、尾删 ***\n");
	printf("*** 5、打印   6、查找 ***\n");
	printf("*** 7、 指定位置插入  ***\n");
	printf("*** 8、 指定位置删除  ***\n");
	printf("***     0、退出      ***\n");
	printf("************************\n");
}
int main()
{
	int input = 0;
	SL ps = { 0 };
	int pos = 0;
	SLDataType x = 0;
	//顺序表的初始化
	SeqListInit(&ps);
	do
	{
		menu();
		printf("请输入你想进行的操作:>\n");
		scanf("%d", &input);
		switch (input)
		{
		case 0:
			printf("退出\n");
			//销毁顺序表
			SeqListDestroy(&ps);
			break;
		case 1:
			//头插数据
			printf("请输入你要头插的数据\n");
			while(scanf("%d", &x) != EOF)
			SeqListPushFront(&ps, x);
			break;
		case 2:
			//头删数据
			SeqListPopFront(&ps);
			break;
		case 3:
			//尾插数据
			printf("请输入你要尾插的数据\n");
			while (scanf("%d", &x) != EOF)
			SeqListPushBack(&ps, x);
			break;
		case 4:
			//尾删数据
			SeqListPopBack(&ps);
			break;
		case 5:
			//打印顺序表
			SeqListPrint(&ps);
			break;
		case 6:
			//查找顺序表中的某个元素，pos是数组下标
			printf("请输入你要查找的数据\n");
			scanf("%d", &x);
			pos = SeqListFind(&ps,x);
			if (pos == -1)
				printf("你要查找的元素不存在\n");
			else
				printf("该元素下标为%d\n",pos);
			break;
		case 7:
			//指定位置插入数据
			printf("请输入你要插入位置的下标和插入的数据\n");
			while (scanf("%d %d",&pos, &x) != EOF)
			SeqListInsert(&ps, pos, x);
			break;
		case 8:
			//指定位置删除数据
			printf("请输入你要删除位置的下标\n");
			while (scanf("%d", &pos) != EOF)
			SeqListErase(&ps, pos);
			break;
		default:
			printf("无此选项，请重新输入!\n");
		}
	} while (input);
	return 0;
}

SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"
//顺序表初始化的实现
void SeqListInit(SL* pc)
{
	pc->a = NULL;
	pc->sz = pc->capacity = 0;//连续赋值
}

//顺序表检查容量的函数
void CheckCapacity(SL* pc)
{
	if (pc->sz == pc->capacity)
	{
		int newcapacity = pc->capacity == 0 ? 4 : pc->capacity * 2;
		//因为==的优先级高于?: 所以先判断是否容量为0
		//这个操作的成功性在于了解运算符的优先级性
		SLDataType* ptr = (SLDataType*)realloc(pc->a, newcapacity * sizeof(SLDataType));
		if (ptr != NULL)
		{
			pc->a = ptr;
			pc->capacity = newcapacity;
		}
		else
		{
			printf("realloc fail\n");
			exit(-1);
			//开辟都失败了，这个程序就没必要往下走了
			//直接一个exit，终止程序
			//exit正常退出返回0  exit(0)
			//exit异常退出，写个-1就行 exit(-1)
		}
	}
}
//顺序表尾插数据的实现
void SeqListPushBack(SL* pc, SLDataType x)
{
	//先检查容量，不够就进行扩容
	CheckCapacity(pc);
	pc->a[pc->sz] = x;
	pc->sz++;
}

//顺序表尾删数据的实现
void SeqListPopBack(SL* pc)
{
//删除的前提是顺序表有元素
//assert条件为真，往下执行，为假，直接程序报错
//这是一个比较粗暴的方式，也可以用if条件判断
//assert记得引头文件
//可以直接pc->sz--是因为顺序表是连续存储不间断的
//--后一定是把最后一个元素删掉的，而头删肯定就不能这么做
	assert(pc->sz > 0);
	pc->sz--;
}


//顺序表打印数据的函数的实现
void SeqListPrint(SL* pc)
{
	int i = 0;
	for (i = 0; i < pc->sz; i++)
	{
		printf("%d ", pc->a[i]);
	}
	printf("\n");
}

//销毁顺序表的函数实现
void SeqListDestroy(SL* pc)
{
	free(pc->a);
	pc->a = NULL;
	pc->capacity = 0;
	pc->sz = 0;
}

//顺序表头插数据的函数实现
void SeqListPushFront(SL* pc,SLDataType x)
{
	CheckCapacity(pc);
	//挪动数据
	int end = pc->sz - 1;
	while (end >= 0)
	{
		pc->a[end + 1] = pc->a[end];
		end--;
	}
	pc->a[0] = x;
	pc->sz++;
}

//顺序表头删数据的函数实现
void SeqListPopFront(SL* pc)
{
	assert(pc->sz > 0);
	//挪动数据
	int begin = 0;
	while (begin < pc->sz-1)
	{
		pc->a[begin] = pc->a[begin + 1];
		begin++;
	}
	pc->sz--;
}

//查找顺序表中数据的函数实现
//规定找到范围数组元素下标
//没找到返回-1
int SeqListFind(SL* pc, SLDataType x)
{
	int i = 0;
	for (i = 0; i < pc->sz; i++)
	{
		if (pc->a[i] == x)
		{
			return i;
		}
	}
	return -1;
}

//顺序表中插入指定位置(数组下标为pos)的数据的函数
void SeqListInsert(SL* pc,int pos,SLDataType x)
{	//温柔的处理方式
	//插入位置的检查，不能越界
	//if (pos > pc->sz || pos < 0)
	//{
	//	//这里为什么不用perror直接打印动态开辟的错误信息?
	//	//因为perror是调用c语言的一些库函数失败的时候去打印的
	//	//他会打印库函数调用失败的原因，比如main,fopen函数等
	//	printf("pos invalid\n");
	//	//这里不用perror是因为pos可能是因为传参失败
	//	//不是库函数调用失败问题，所以不用
	//	return;
	//}
	//粗暴的处理方式
	assert(pos <= pc->sz && pos >= 0);
	CheckCapacity(pc);
	int end = pc->sz;
	while (end > pos)
	{
		pc->a[end] = pc->a[end-1];
		end--;
	}
	pc->a[pos] = x;
	pc->sz++;
}

//顺序表中删除指定位置的数据的函数
void SeqListErase(SL* pc, int pos)
{
	assert(pos >= 0 && pos < pc->sz);
	int begin = pos;
	while (begin < pc->sz-1)
	{
		pc->a[begin] = pc->a[begin + 1];
		begin++;
	}
	pc->sz--;
}

SeqList.h

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

typedef int SLDataType;

//动态顺序表
typedef struct SeqList
{
	SLDataType* a;
	int sz;//当前顺序表存的有效数据的个数
	int capacity;//当前顺序表的最大容量的个数
}SL;

//顺序表初始化的声明
void SeqListInit(SL* pc);
//顺序表尾插函数的声明
void SeqListPushBack(SL* pc, SLDataType x);
//顺序表尾删函数的声明
void SeqListPopBack(SL* pc);
//顺序表打印数据的函数声明
void SeqListPrint(SL* pc);
//顺序表销毁函数的声明（因为是动态开辟的，内存需要释放）
void SeqListDestroy(SL* pc);
//顺序表头插数据的函数声明
void SeqListPushFront(SL* pc,SLDataType x);
//顺序表头删数据的函数声明
void SeqListPopFront(SL* pc);
//找顺序表中数据的函数声明
int SeqListFind(SL* pc, SLDataType x);
//顺序表中插入指定位置的数据的函数声明
void SeqListInsert(SL* pc, int pos, SLDataType x);
//顺序表中删除指定位置的数据的函数声明
void SeqListErase(SL* pc, int pos);

姜暮、
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tastylib：数据结构，算法和系统设计的C ++实现
01-30
美味库 数据结构，算法和有用设计的C ++实现。 建立状态 Linux 视窗 覆盖范围 大纲 数据结构 名称 资源 基准化 注意 定义 是 链接的数据结构，由一组顺序链接的记录组成。 它还支持合并排序。 是 采用完整二进制树形式的堆数据结构。 实现一种通用方法。 没有 一种数据结构，不按特定顺序存储唯一元素，并允许根据其值快速检索各个元素。 类似于 。 是 自平衡二进制搜索树。 没有 一种数据结构，用于实现数学中的有向/无向图概念。 它将图存储在邻接表或矩阵中。 演算法 名称 资源 基准化 注意 定义 是 广泛使用的哈希函数可产生128位哈希值。 是 包括，，，和。 有关，请参阅 。 没有 查找图中顶点之间最短路径的算法。 没有 查找两个序列共有的最长子序列或子字符串的动态编程解决方案。 设计图 名称 资源 基准化 注意 参考 是 用解决的经典搜索问题。 没有 在给定的输入流中搜索单词。 （OOP练习） §12.3和§15.9，C ++ Primer，第5版 没有 我自己的版本。 §12.1和§16.1.6，C ++ Primer，第5版 没有 我
清华大学-数据结构1
09-03
清华大学-数据结构1 本书是根据严蔚敏、吴伟民编著的《数据结构》（C语言版）而编写的辅助教材。 全书共分两部分，第1部分按原教材章节顺序，分为12章，每章按知识脉络图解、重点和难点解读、课程考试和考研要点、典型例题及习题精选详解等四个知识模块编写。第2部分给出了几套课程考试模拟试题和精选了部分各大名校近几年硕士研究生入学考试题，并附有参考答案。本书内容充实完整，层次分明，概念清晰，表达方式易于接受，有利于学生对“数据结构”课程知识的理解，帮助学生从广大和深度上把握知识体系，拓宽解题思路，提高解题能力。 本书针对性强、习题覆盖面广，适用于考研者应试提高，也可作为计算机及相关专业学生学习“数据结构”课程的指导书。
顺序表的创建
李洙赫的博客
05-16 8217
1、数据结构的最简单的顺序表。 顺序表功能就是插入数据、删除数据、打印数据。 其他函数就是在这几个的基础上修改 第一步：插入数据 首先先创建一个顺序表并且初始化 顺序表就相当于是一个数组。 初始化好了之后就是插入数据了 然后删除数据 这应该是最简单的一步了。 打印数据 完整代码： //顺序表的基本实现 //定义一个结构体 typedef struct SLlist { int* a;//数组 int size;//个数 int capacity;...
数据结构之顺序表的实现（详解！附完整代码）
逃离枷锁，冲向天空！
11-08 1262
首先为了方便顺序表的灵活运用，我们用typedef来在头文件中定义int为SLDateType，如果下次是字符型的数据，我们只需要在这里将int改为char，后续的代码就不用更改，其次我们定义一个结构体为顺序表。在这里的插入数据，我们首先要将知道pos位置，而且pos位置要是大于等于0，小于等于size的，因为头插就是下标为0的位置，尾插就是下标为size的位置，之前的头插尾插我们可以直接用这个函数。同样的我们首先检查容量，并且要将所有的数据后移一位，再将数据x插入数组下标为0的位置，同时size++
【数据结构】实现顺序表（c++）
zhaoyaqian552的专栏
05-18 630
头文件： #pragma once #include using namespace std; template class SeqList { public: SeqList(size_t sz = INIT_SIZE); ~SeqList(); public: bool isfull()const { return size > capacity; }
【数据结构】顺序表的实现
m0_59292239的博客
10-26 2811
【数据结构】顺序表的实现
数据结构与算法 --顺序表的创建
weixin_53459503的博客
07-09 3421
顺序表是一种线性表的实现方式，通过连续的内存空间存储元素，按照顺序排列。顺序表是一种常见的数据结构，常用于解决各种问题，在实际应用中，根据具体需求选择合适的数据结构，以满足操作的效率和灵活性要求。
【（数据结构）- 顺序表的实现】
qq_73900397的博客
10-13 597
（数据结构）- 顺序表的实现
数据结构- 顺序表的实现
曾铎的博客
08-29 712
在计算机内部存储一张线性表（线性结构的数表），最为方便简单的就是用一组连续的地址的内存单元来存储整张线性表。这种存储结构称为顺序存储结构。这种存储结构下的线性表就称为顺序表。一张顺序表包括这几个特征：有一个唯一的表名来标识该顺序表；内存单元连续存储，也就是说一张顺序表必须要占据一块连续的内存空间；数据顺序存放，元素之间有先后关系；定义一张顺序表也就是在内存中开辟一段连续的存储空间，同时我们定义的顺序表也应该实现增删查改这四个功能。......
【 数据结构 】顺序表的实现 - 详解（C语言版）
上上谦. 的博客
03-13 7792
目录 前言 线性表： ​ 顺序表： 概念及结构： 顺序表的实现： 头文件：SeqList.h realloc函数讲解： 具体函数的实现：SeqList.c 顺序表的初始化： 顺序表的打印： 容量的检查： 顺序表的尾插： 顺序表的尾删： 顺序表的头插： 顺序表的头删： 在顺序表的指定位置插入数据： 在顺序表的指定位置删除数据： 顺序表的查找： 顺序表的修改： 顺序表的销毁： 数组越界的检查： 前言 简单用C语言来描述数据结构中的顺序表......
[详细完整版]数据结构2.doc
07-11
数据域内只放空表标志和表长等信息 （内放头指针?那还得另配一个头指针!） 首元素结点:是指链表中存储线性表中第一个数据元素a1的结点. 2.2 链式存储结构一般说克服了顺序存储结构的三个弱点。首先，插
Dialogic从入门到系统工程师_完整版
04-27
有很多只有333页 我这个是完整版本 总共666页 序言 14 写作本书的原因 14 目标读者 15 作者编写的其他书籍 15 第一章 CTI通信基础知识 16 1.1 概述 16 1.2 电信技术概念和术语 16 1.2.1 模拟信号和数字信号 ...
数据结构中的顺序表的实现
weixin_58016534的博客
06-05 835
本期主要分享了数据结构的总体章程以及数据结构中顺序表的实现过程，那么给出了顺序存储的两种形式（定义结构体不同），当然，萝卜白菜各有所爱，我比较喜欢第一种，操作起来比较方便，因为它在结构体中直接存储了顺序表的总个数，显得整个顺序表具有整体性；但是两种形式在本质上气势上是一样的，都是顺序表且本质完全一致；小伙伴们学起来，加油！
数据结构 深入理解顺序表的实现
qq_72486849的博客
07-12 401
在Java和C++的学习当中，前期学习数据结构当中的顺序表、链表、二叉树等便于我们后面更好的学习容器
数据结构（C描述）——顺序表的功能实现（全）
EchoToMe的博客
12-12 358
数据结构（C语言描述） ----顺序表的功能实现 功能十分的全面
【数据结构（C语言）】顺序表的定义，实现初始化、创建、插入、增、删、改、查等基本操作（详细）
热门推荐
DuFengYa的博客
05-21 1万+
顺序表是在计算机内内存中以数组的形式保存的线性表， 线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、 使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中， 即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系， 采用顺式存储结构的线性表通常称为顺序表。 相对于链式存储结构而言，顺式存储结构显得更为简单。 顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 顺序表的基本运算有： 初始化 查找 插入 删除 输.
顺序表的创建，插入，删除，查找，取值，输出，退出功能实现
naozibuok的博客
04-01 1344
顺序表的创建，插入，删除，查找，取值，输出，退出功能实现。
【数据结构之顺序表的的表示和实现】
m0_66604512的博客
07-05 1402
顺序表是线性表的一种，是指用一组地址连续的存储单元依次存储线性表的数据元素。其特点是，逻辑上相邻的数据元素，其物次序也是相邻的。所以顺序表具有随机存取的性质。 顺序表中的基本操作有很多取值、赋值、查找、插入、删除、排序、销毁、重置等等。...............
数据结构---线性表（顺序表）附代码
最新发布
2302_81153999的博客
04-27 753
假定数组有10个空间，已经使用了5个，向数组中插入数据步骤： 求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插⼊数据（注意：这里是否要判断数组是否满了，满了还能继续插⼊吗）..... 假设数据量非常庞大，频繁的获取数组有效数据个数会影响程序执行效率。同理，程序中如果不对数据进行管理，可能会导致数据丢失、操作数据困难、野指针等情况。常见的数值1、2、3、4.....、教务系统里保存的用户信息（姓名、性别、年龄、学历等 ）、网页里肉眼可以看到的信息（文字、图片、视频等等），这些都是数据。
数据结构顺序表的实现
06-02
顺序表是一种简单的数据结构，它可以用一块连续的内存空间存储具有相同类型的数据元素。下面是顺序表的实现： ```c++ #define MaxSize 100 // 定义最大长度 typedef struct { int data[MaxSize]; // 用数组存储数据元素 int length; // 当前长度 } SqList; // 初始化顺序表 void InitList(SqList &L) { for (int i = 0; i < MaxSize; i++) { L.data[i] = 0; // 将数组元素全部赋值为0 } L.length = 0; // 初始化顺序表长度为0 } // 插入元素 bool InsertList(SqList &L, int i, int x) { if (i < 1 || i > L.length + 1) { // 判断i的范围是否有效 return false; } if (L.length >= MaxSize) { // 判断顺序表是否已满 return false; } for (int j = L.length; j >= i; j--) { // 将第i个元素及之后的元素后移 L.data[j] = L.data[j - 1]; } L.data[i - 1] = x; // 在位置i处插入新元素x L.length++; // 长度加1 return true; } // 删除元素 bool DeleteList(SqList &L, int i) { if (i < 1 || i > L.length) { // 判断i的范围是否有效 return false; } for (int j = i; j < L.length; j++) { // 将第i个元素之后的元素前移 L.data[j - 1] = L.data[j]; } L.length--; // 长度减1 return true; } // 查找元素 int SearchList(SqList L, int x) { for (int i = 0; i < L.length; i++) { if (L.data[i] == x) { return i + 1; // 返回元素的位置 } } return 0; // 未找到返回0 } // 输出顺序表 void PrintList(SqList L) { for (int i = 0; i < L.length; i++) { cout << L.data[i] << " "; } cout << endl; } ``` 其中，`InitList`函数用于初始化顺序表，`InsertList`函数用于在顺序表的第`i`个位置插入元素`x`，`DeleteList`函数用于删除顺序表的第`i`个元素，`SearchList`函数用于查找元素`x`在顺序表中的位置，`PrintList`函数用于输出顺序表中的所有元素。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值