数据结构——顺序表

于 2024-07-03 20:55:27 发布
阅读量154 收藏 1
点赞数 6
分类专栏： 数据结构 文章标签： 数据结构 c语言 visual studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quite123_/article/details/140160941
版权

顺序表分为定长顺序表、不定长顺序表

一、定长顺序表

1、结构体

typedef   struct  SQList
{
	int  elem[10];//存放数据,固定长度为10
	int  length;//有效数据的长度
}SQList, * PSQList;

2、初始化

void  InitSqlist(PSQList  ps)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return;
	}
	ps->length = 0;
}

3、插入数据

先找到要插入的位置pos，将pos之后的数往后移，再将数val插入pos位置，最后将表长++

bool  Insert(PSQList ps, int pos, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	if (pos<0 || pos>ps->length || Full(ps))
	{
		return false;
	}
	//将pos后面的数往后移，找到pos位置
	for (int i = ps->length-1 ; i >= pos; i--)
	{
		ps->elem[i + 1] = ps->elem[i];
	}
	//插入数据
	ps->elem[pos] = val;
	//顺序表长度++
	ps->length++;
	return true;
}

4、删除数据val

先找到val的位置，再将其删除

//在ps中查找第一个key值,找到返回下标,没有找到返回-1
int   Search(PSQList   ps, int key)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return -1;
	}
	//找到key
	for (int i = 0; i < ps->length - 1; i++)
	{
		if (ps->elem[i] == key)
		{
			return i;
		}
	}
	return -1;
}
//删除pos位置的值
bool   DelPos(PSQList ps, int pos)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	if (pos<0 || pos>ps->length || IsEmpyt(ps))
	{
		return false;
	}
	//将pos位置后面的数往前移动一位
	for (int i = pos; i < ps->length - 1; i++)
	{
		ps->elem[i] = ps->elem[i + 1];
	}
	ps->length--;
	return true;
}
//删除第一个val的值
bool  DelVal(PSQList ps, int val)
{
	int tmp = Search(ps, val);
	if (tmp < 0)
	{
		return false;
	}
	else
	{
		return DelPos(ps, tmp);
	}
}

5、完整代码

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include <string.h>
#include<ctype.h>
#include<assert.h>
//定义与声明
typedef   struct  SQList
{
	int  elem[10];//存放数据,固定长度为10
	int  length;//有效数据的长度
}SQList, * PSQList;

//初始化
void  InitSqlist(PSQList  ps)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return;
	}
	ps->length = 0;
}

static bool Full(PSQList ps)
{
	return ps->length == 10;
}
//插入数据,在ps顺序表的pos位置插入val;
bool  Insert(PSQList ps, int pos, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	if (pos<0 || pos>ps->length || Full(ps))
	{
		return false;
	}
	//将pos后面的数往后移，找到pos位置
	for (int i = ps->length-1 ; i >= pos; i--)
	{
		ps->elem[i + 1] = ps->elem[i];
	}
	//插入数据
	ps->elem[pos] = val;
	//顺序表长度++
	ps->length++;
	return true;
}

//判空
bool   IsEmpyt(PSQList ps)
{
	return ps->length == 0;
}

//在ps中查找第一个key值,找到返回下标,没有找到返回-1
int   Search(PSQList   ps, int key)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return -1;
	}
	//找到key
	for (int i = 0; i < ps->length - 1; i++)
	{
		if (ps->elem[i] == key)
		{
			return i;
		}
	}
	return -1;
}


//删除pos位置的值
bool   DelPos(PSQList ps, int pos)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	if (pos<0 || pos>ps->length || IsEmpyt(ps))
	{
		return false;
	}
	//将pos位置后面的数往前移动一位
	for (int i = pos; i < ps->length - 1; i++)
	{
		ps->elem[i] = ps->elem[i + 1];
	}
	ps->length--;
	return true;
}

//删除第一个val的值
bool  DelVal(PSQList ps, int val)
{
	int tmp = Search(ps, val);
	if (tmp < 0)
	{
		return false;
	}
	else
	{
		return DelPos(ps, tmp);
	}
}

//返回key的前驱下标,如果不存在返回-1
int  GetPrio(PSQList  ps, int key)
{
	int tmp = Search(ps, key);
	if (tmp < 0)
	{
		return -1;
	}
	else
	{
		return tmp-1;
	}
}


//返回key的后继下标,如果不存在返回-1
int  GetNext(PSQList  ps, int key)
{
	int tmp = Search(ps, key);
	if (tmp < 0)
	{
		return -1;
	}
	else
	{
		return tmp + 1;
	}
}

//输出
void  Show(PSQList  ps)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return ;
	}
	for (int i = 0; i < ps->length; i++)
	{
		printf("%d ", ps->elem[i]);
	}
	printf("\n");
}

//清空数据
void  Clear(PSQList ps)
{
	ps->length = 0;
}

//销毁整个内存
void   Destroy(PSQList  ps)
{
	Clear(ps);
}

int main()
{
	SQList ps;
	InitSqlist(&ps);
	for (int i = 0; i < 9; i++)
	{
		Insert(&ps, i, i);
	}
	Show(&ps);
	DelVal(&ps, 5);
	Show(&ps);
	Insert(&ps, 6, 10);
	Show(&ps);
	Clear(&ps);
	Show(&ps);
}

二、不定长顺序表

1、结构体

typedef struct DSQList
{
	int* elem;//动态内存的地址
	int length;//有效数据长度
	int listsize;//总容量
}DSQList,*DSQ;

2、初始化

void Initlist(DSQ ps)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return;
	}
	ps->elem = (int*)malloc(INITSIZE * sizeof(int));
	ps->length = 0;
	ps->listsize = INITSIZE;
}

3、插入数据

先判断是否还有空间，若有则将pos之后的数据往后移

//在pos插入数据val
bool Insert(DSQ ps, int pos, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return NULL;
	}
	if (IsFull(ps))//判满
	{
		Roc(ps);
	}
	if (pos<0 || pos>ps->length)
	{
		return false;
	}
	//移动数据
	for (int i = ps->length - 1; i >= pos; i--)
	{
		ps->elem[i + 1] = ps->elem[i];
	}
	//插入数据
	ps->elem[pos] = val;
	ps->length++;
	return true;
}

4、删除数据val

//查找val并返回其下标
int Search(DSQ ps, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return -1;
	}
	for (int i = 0; i < ps->length - 1; i++)
	{
		if (ps->elem[i] == val)
		{
			return i;
		}
	}
	return -1;
}
//删除pos位置的值
bool Delkey(DSQ ps, int pos)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	if (pos<0 || pos>ps->length)
	{
		return NULL;
	}
	for (int i = pos; i < ps->length - 1; i++)
	{
		ps->elem[i] = ps->elem[i + 1];
	}
	ps->length--;
	return true;
}
//删除第一个val
bool Delval(DSQ ps, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	int tmp = Search(ps, val);
	if (tmp < 0)
		return false;
	else
		return Delkey(ps, tmp);

}

5、完整代码

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<math.h>
#include <string.h>
#include<ctype.h>
#include<assert.h>
#include<malloc.h>
#define INITSIZE 10
typedef struct DSQList
{
	int* elem;//动态内存的地址
	int length;//有效数据长度
	int listsize;//总容量
}DSQList,*DSQ;
//初始化
void Initlist(DSQ ps)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return;
	}
	ps->elem = (int*)malloc(INITSIZE * sizeof(int));
	ps->length = 0;
	ps->listsize = INITSIZE;
}
//判满
static bool IsFull(DSQ ps)
{
	return ps->length == ps->listsize;
}
//扩容
static bool Roc(DSQ ps)
{
	ps->elem = (int*)realloc(ps->elem, 2 * sizeof(int) * ps->listsize);
	assert(ps->elem != NULL);
	ps->listsize *= 2;
	return true;
}
//在pos插入数据val
bool Insert(DSQ ps, int pos, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return NULL;
	}
	if (IsFull(ps))//判满
	{
		Roc(ps);
	}
	if (pos<0 || pos>ps->length)
	{
		return false;
	}
	//移动数据
	for (int i = ps->length - 1; i >= pos; i--)
	{
		ps->elem[i + 1] = ps->elem[i];
	}
	//插入数据
	ps->elem[pos] = val;
	ps->length++;
	return true;
}
//判空
static bool IsEmpty(DSQ ps)
{
	return ps->length == 0;
}

//查找val并返回其下标
int Search(DSQ ps, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return -1;
	}
	for (int i = 0; i < ps->length - 1; i++)
	{
		if (ps->elem[i] == val)
		{
			return i;
		}
	}
	return -1;
}
//删除pos位置的值
bool Delkey(DSQ ps, int pos)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	if (pos<0 || pos>ps->length)
	{
		return NULL;
	}
	for (int i = pos; i < ps->length - 1; i++)
	{
		ps->elem[i] = ps->elem[i + 1];
	}
	ps->length--;
	return true;
}
//删除第一个val
bool Delval(DSQ ps, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	int tmp = Search(ps, val);
	if (tmp < 0)
		return false;
	else
		return Delkey(ps, tmp);

}
//返回val的前驱下标
int Qindex(DSQ ps, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return -1;
	}
	int tmp = Search(ps, val);
	if (tmp < 0)
		return -1;
	else
		return tmp-1;
}
//返回val的后继下标
int Bindex(DSQ ps, int val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return -1;
	}
	int tmp = Search(ps, val);
	if (tmp < 0)
		return -1;
	else
		return tmp + 1;
}
//输出
void  Show(DSQ  ps)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return;
	}
	for (int i = 0; i < ps->length; i++)
	{
		printf("%d ", ps->elem[i]);
	}
	printf("\n");
}

//清空数据
void  Clear(DSQ ps)
{
	ps->length = 0;
}

//销毁整个内存
void   Destroy(DSQ  ps)
{
	free(ps->elem);
	ps->elem = NULL;
	ps->length = 0;
	ps->listsize = 0;
}

int main()
{
	DSQList ps;
	Initlist(&ps);
	for (int i = 0; i < 9; i++)
	{
		Insert(&ps, i, i);
	}
	Show(&ps);
	Delval(&ps, 5);
	Show(&ps);
	Insert(&ps, 6, 10);
	Show(&ps);
	Insert(&ps, 9, 100);
	Show(&ps);
	printf("请找到10的前驱下标：%d", Qindex(&ps, 10));
}

三、顺序表的特点

①插入数据的时间复杂度是O(n),如果是尾插时间复杂度是O(1);

②删除数据的时间复杂度是O(n),如果是尾删时间复杂度是O(1);

③通过下标访问数据时间复杂度是O(1);
        顺序表逻辑上相邻的元素物理上也相邻,所以插入和删除操作需要移动大量元素;存储密度大(高),每个结点只存储数据元素(对比链表);

补充：

随机访问:顺序表是一种支持随机存取的存储结构,根据起始地址加上元素的序号,可以在O(1)时间内找到指定的元素。

CKX源路程
关注
  • 6
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构C++顺序表
03-04
本主题聚焦于一种基础且重要的数据结构——顺序表，尤其关注如何在C++中实现这一概念。 顺序表是一种线性数据结构，其中元素在内存中按顺序存储。在C++中，我们可以使用数组来实现顺序表。这种结构的优点是访问速度...
数据结构——顺序表的合并
qq_45966201的博客
02-02 1万+
数据结构——顺序表的合并 具体要求：写一个函数，其函数的功能是将非递增顺序表LA和LB合并到非递增顺序表LC中 数据结构—顺序表的操作之合并顺序表 一、顺序表的结构 首先要定义的是顺序表的结构体，只有先定义了顺序表的结构体类型，才可以继续进行下一步操作 #define maxsize 100 typedef struct { int elem[maxsize];//线性表元素 int last;//线性表长度 }SeqList; 二、顺序表的操作 1.生成顺序表 在有了顺序表的结构之后，
数据结构——顺序表（C语言编写）
新手小白
09-17 7885
数据结构，顺序表应用 插入、删除、合并...
数据结构——顺序表（定义、实现）
weixin_62677583的博客
12-19 2994
这里写目录标题一级目录二级目录三级目录 一级目录 二级目录 三级目录
数据结构 ——顺序表【c语言版】
clear-ninghongkang的博客
11-19 6008
线性表：具有相同特性的数据元素（既同类型数据）的一个有限序列. 注：同一线性表中的元素必定具有相同特性 线性表的特性：1.有穷性 2.一致性 3.序列性 线性表的最本质特征：有唯一的前驱和后继 线性表的顺序存储结构———顺序表 顺序存储结构——逻辑上相邻的元素，在物理上也相邻 在c语言中，顺序表通常用数组来存储，这与python中的列表不同，数组是给定长度的，数组中元素的地址也是相邻的，且数组中的元素类型一定要相同,而列表list是的长度理论上是可以无限添加的，(因为pyt...
数据结构——顺序表的逆置
热门推荐
luladuck的博客
03-20 1万+
题目：请写一个算法将顺序存储结构的线性表（a1...an）逆置为(an...a1)，要求使用最少的附加空间。 解析：可以理解为一个线性表内的交换问题。当n为奇数时，将第一个元素与最后一个元素进行交换，第二个元素与倒数第二个元素进行交换，以此类推，最中间的元素不用进行交换（n/2+1）。当n为偶数时，规则与奇数时一样，只是最中间两个元素也要进行交换（n/2 <----> n/2+1）。 核心代码： //核心代码 void Inverse(SqList &L) { int i, t
数据结构——顺序表（Ｃ语言版）
weixin_53811859的博客
03-30 6554
室友一把王者的时间，手把手带你拿捏严奶奶数据结构里面的动态顺序表实现（C语言版），纯手工绘画，保证让初学者的xdm也一目了然，精简易懂
数据结构 —— 顺序表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-04 3305
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。
数据结构——顺序表的C语言实现
Winters_coming的博客
10-27 3905
郫县电子专科学院的在读大二，再次保存代码供参考及批评指正 ex1_1——基本题： 1）首先创建一个顺序表：从键盘读入一组整数（长度小于等于20），按输入顺序放入顺序表，输入以－1结束（注意－1不放到顺序表内）；将创建好的顺序表元素依次输出到屏幕上。 2）在已创建好的顺序表中插入一个元素：从键盘读入需插入的元素值和插入位置，调用插入函数完成插入操作；然后将顺序表元素依次输出到屏幕上。 3）在...
数据结构——顺序表——最大连续1的个数
最新发布
qq_48335434的博客
04-07 267
数据结构——顺序表——最大连续1的个数
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
数据结构实验——顺序表
12-22
顺序表作为数据结构的一种，是我们在学习和实践中经常会遇到的概念。在这个实验中，我们将深入探讨顺序表的实现及其相关操作。 顺序表是一种线性数据结构，它的元素在内存中是连续存放的，就像数组一样。每个元素都...
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
注：分为三个内容：顺序表、单链表、运行结果。代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-...
数据结构——用现有链表转换为顺序表
06-26
用链表创建顺序表，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
数据结构-顺序表C++实现
03-30
在本实验中，我们将关注一种基础且重要的数据结构——顺序表，它在C++中得到了实现。顺序表是一种线性数据结构，其中元素按照它们被添加的顺序存储在连续的内存空间中。 首先，我们要理解顺序表的基本操作。顺序表...
合工大数据结构顺序表实验
04-14
本实验“合工大数据结构顺序表实验”聚焦于数据结构中的一个重要基础概念——顺序表。顺序表是一种线性数据结构，其中元素在内存中以连续的方式存储，就像数组一样。对于18级合工大的学生来说，这个实验旨在深化他们...
数据结构——单链表.zip
09-16
本资料包"数据结构——单链表.zip"专注于单链表的实现，特别针对严蔚敏教授的数据结构教材内容进行了完整的编程实现。下面，我们将深入探讨单链表及其相关操作。 单链表是一种线性数据结构，每个元素称为节点，每个...
第2章线性表1
08-04
线性表是一种基本的线性数据结构，它由一组具有线性逻辑关系的数据元素组成，可以在线性表的任意位置进行插入和删除数据元素的操作。线性表的数据元素之间具有顺序关系，每个元素除了第一个和最后一个之外，都有一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

CKX源路程

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

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

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

打赏作者

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

抵扣说明：

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

余额充值