顺序表（数据结构与算法）

已于 2023-12-11 14:10:02 修改
阅读量1.5k 收藏 65
点赞数 118
分类专栏： 数据结构与算法 文章标签： 数据结构 顺序表
于 2023-11-18 14:11:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74967884/article/details/134474319
版权

请添加图片描述

✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿
🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟
🌟🌟 追风赶月莫停留 🌟🌟
🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀
🌟🌟 平芜尽处是春山🌟🌟
🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟
🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿
✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅

🍋顺序表

🍌顺序表的定义

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

在这里插入图片描述

线性表：线性表是最基本、最简单、也是最常用的一种数据结构。大部分线性表除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。而又一些小部分,比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储，但是把最后一个数据元素的尾指针指向了首位结点

🍌顺序表的结构

🍍静态顺序表

静态顺序表就是以一定长度的数组来存储元素

//静态存储
#define  N  5
typedef int SLDetatype ;
typedef struct SeqList
{
	SLDetatype a[N] ;//有限空间的数组
	int size ;//有效的数据个数
}SeqList;

在这里插入图片描述

🍍动态顺序表

动态顺序表使用动态开辟的数组来存储元素

//动态存储
typedef  int SLDetatype ;
typedef struct SeqList
{
	SLDetatype *a ;   //指向动态开辟的数组
	int size ;       //有效的数据个数
	int capicity ;   //空间的容量
}SeqList;

在这里插入图片描述

🍌顺序表接口的实现（增删查改）

🍍其它接口

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

typedef int SLDatatype;
typedef struct SeqList
{
	SLDatatype* a;
	int capacity;
	int size;
}SeqList;

🍍顺序表初始化

void SeqListInit(SeqList* ps)
{
	ps->a = NULL;            
	//在初始情况我们可以直接置空
	//当然也可以创建空间，看自己习惯
	ps->capacity = ps->size = 0;
}

🍍检查空间是否增容（空间满了就增容）

void CheckCapacity(SeqList* ps)
{
	assert(ps);
	//在两个相等时，空间可能会满，还可能空间为0，这是因为我们在初始化没有创建空间导致
	if (ps->capacity == ps->size)
	{
		if (ps->capacity == 0)
			ps->capacity = 2;
		else
			ps->capacity *= 2;
		int newcapacity = ps->capacity;
		//在扩容时，我们都是利用realloc,创建空间利用malloc
		SLDatatype* cur = (SLDatatype*)realloc(ps->a, sizeof(SLDatatype) * newcapacity);
		if (cur == NULL)
		{
			perror("realloc   faild");
			exit(-1);
		}
		ps->a = cur;
		ps->capacity = newcapacity;
	}
}

大家如果对于malloc和realloc以及空间的创建的用法有些遗忘，可以看我这篇博客：动态内存管理（这是一个链接，有需要的朋友可以直接点进去）

🍍顺序表尾插

void SeqListPushBack(SeqList* ps, SLDatatype x)
{
	assert(ps);
	CheckCapacity(ps);  //需要检查空间是否满或者空
	ps->a[ps->size] = x;
	(ps->size)++;
}

在这里插入图片描述

🍍顺序表尾删

//顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);  //检查数据个数是否为0，如果为0就不执行，反之亦然
	(ps->size)--;
}

在这里插入图片描述

🍍顺序表头插

// 顺序表头插
void SeqListPushFront(SeqList* ps, SLDatatype x)
{
	assert(ps);
	CheckCapacity(ps);//判断空间是否满还是空
	//注意头插要分两种情况
	//第一种是数组里没有元素，此时头插就是相当于尾插
	//第二种是数组里有元素，这时就先把整体元素往后移动一位
	if (ps->size - 1 == 0)
	{
		ps->a[ps->size -1] = x;
		(ps->size)++;
	}
	else
	{
		int end = ps->size - 1;
		while (end >= 0)
		{
			ps->a[end + 1] = ps->a[end];
			end--;
		}
		ps->a[0] = x;
		(ps->size)++;
	}
}

注意：
注意头插要分两种情况
（1）第一种是数组里没有元素，此时头插就是相当于尾插
（2）第二种是数组里有元素，这时就先把整体元素往后移动一位

在这里插入图片描述

🍍顺序表头删

// 顺序表头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	//注意头删要分两种情况
	//第一种是数组里没有元素，此时头删就是相当于尾删
	//第二种是数组里有元素，这时就需要把除了第一个元素外的所有元素往前移动一位，把原来的第一位元素覆盖
	if (ps->size - 1 == 0)
	{
		(ps->size)--;
	}
	else
	{
		int end = 0;
		while (end < ps->size - 1)
		{
			ps->a[end] = ps->a[end + 1];
			end++;
		}
		(ps->size)--;
	}
}

注意:
注意头删要分两种情况
（1）第一种是数组里没有元素，此时头删就是相当于尾删
（2）第二种是数组里有元素，这时就需要把除了第一个元素外的所有元素往前移动一位，把原来的第一位元素覆盖

在这里插入图片描述

🍍顺序表查找

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

🍍顺序表在pos位置插入x

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDatatype x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	CheckCapacity(ps);
	int i = 0;
	for (i = pos - 1; i < ps->size - 1; i++)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[pos-1] = x;
	(ps->size)++;
}

注意:pos必须在0到ps->size之间

在这里插入图片描述

🍍顺序表删除pos位置的值

// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	int i = 0;
	for (i = pos - 1; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	(ps->size)--;
}

注意：pos必须在0到ps->size之间

🍍顺序表修改pos位置的值

//顺序表修改pos位置的值
void SeqModify(SeqList* ps, int pos, SLDatatype x)
{
	assert(ps);

	assert(pos >= 0 && pos < ps->size);

	ps->a[pos - 1] = x;
}

🍍顺序表销毁

// 顺序表销毁
void SeqListDestory(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

🍍顺序表打印

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

🍌顺序表整体代码的实现

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

typedef int SLDatatype;
typedef struct SeqList
{
	SLDatatype* a;
	int capacity;
	int size;
}SeqList;

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

//检查空间，如果满了就增容
void CheckCapacity(SeqList* ps)
{
	assert(ps);
	if (ps->capacity == ps->size)
	{
		if (ps->capacity == 0)
			ps->capacity = 2;
		else
			ps->capacity *= 2;
		int newcapacity = ps->capacity;
		SLDatatype* cur = (SLDatatype*)realloc(ps->a, sizeof(SLDatatype) * newcapacity);
		if (cur == NULL)
		{
			perror("realloc   faild");
			exit(-1);
		}
		ps->a = cur;
		ps->capacity = newcapacity;
	}
}

//顺序表尾插
void SeqListPushBack(SeqList* ps, SLDatatype x)
{
	assert(ps);
	CheckCapacity(ps);
	ps->a[ps->size] = x;
	(ps->size)++;
}

//顺序表尾删
void SeqListPopBack(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	(ps->size)--;
}

// 顺序表头插
void SeqListPushFront(SeqList* ps, SLDatatype x)
{
	assert(ps);
	CheckCapacity(ps);
	if (ps->size == 0)
	{
		ps->a[ps->size] = x;
		(ps->size)++;
	}
	else
	{
		int end = ps->size - 1;
		while (end >= 0)
		{
			ps->a[end + 1] = ps->a[end];
			end--;
		}
		ps->a[0] = x;
		(ps->size)++;
	}
}

// 顺序表头删
void SeqListPopFront(SeqList* ps)
{
	assert(ps);
	assert(ps->size > 0);
	if (ps->size - 1 == 0)
	{
		(ps->size)--;
	}
	else
	{
		int end = 0;
		while (end < ps->size - 1)
		{
			ps->a[end] = ps->a[end + 1];
			end++;
		}
		(ps->size)--;
	}
}

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

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* ps, int pos, SLDatatype x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	CheckCapacity(ps);
	int i = 0;
	for (i = pos - 1; i < ps->size - 1; i++)
	{
		ps->a[i + 1] = ps->a[i];
	}
	ps->a[pos-1] = x;
	(ps->size)++;
}

// 顺序表删除pos位置的值
void SeqListErase(SeqList* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);
	int i = 0;
	for (i = pos - 1; i < ps->size - 1; i++)
	{
		ps->a[i] = ps->a[i + 1];
	}
	(ps->size)--;
}

// 顺序表销毁
void SeqListDestory(SeqList* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->size = ps->capacity = 0;
}

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


//顺序表修改pos位置的值
void SeqModify(SeqList* ps, int pos, SLDatatype x)
{
	assert(ps);

	assert(pos >= 0 && pos < ps->size);

	ps->a[pos - 1] = x;
}

void test1()
{
	SeqList cur;
	SeqListInit(&cur);
	SeqListPushBack(&cur, 500);//尾插
	SeqListPushBack(&cur, 400);//尾插
	SeqListPushBack(&cur, 300);//尾插
	SeqListPrint(&cur);

	SeqListPopBack(&cur);//尾删
	SeqListPrint(&cur);

	SeqListPushFront(&cur, 100);//头插
	SeqListPushFront(&cur, 200);//头插
	SeqListPushFront(&cur, 600);//头插
	SeqListPrint(&cur);

	SeqListPopFront(&cur); //头删
	SeqListPrint(&cur);

	if (SeqListFind(&cur,200) == 1)//元素查找
		printf("找到了\n");
	else
	{
		printf("没有找到\n");
	}

	SeqListInsert(&cur, 3, 999);//在pos位置插入x
	SeqListPrint(&cur);

	SeqListErase(&cur, 3);//删除pos位置的值
	SeqListPrint(&cur);

	SeqModify(&cur, 3, 666); //修改pos位置的值
	SeqListPrint(&cur);
}

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

在这里插入图片描述

悦心无谓
关注
  • 118
    点赞
  • 踩
  • 65
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 70
    评论
专栏目录
Python数据结构与算法（2.2）——顺序表
盼小辉丶的博客
01-07 2万+
线性表的顺序存储是把线性表的数据元素按逻辑次序依次存放在一组连续的存储单元中，即逻辑结构上相邻的两个数据元素存储在计算机内的物理存储位置也是相邻的，这种存储方法为整个线性表分配一整个内存块保存线性表的元素，借助数据元素在计算机内的物理位置表示线性表中数据元素之间的逻辑关系。采用顺序存储结构表示的线性表简称顺序表 (Sequential List)。本节将介绍顺序表的特点以及各种基本操作的实现。
数据结构与算法实验（C++）：顺序表实验-代码
01-18
1.内容概要： （1）实验目的： 1） 熟练掌握顺序表的存储特点； 2） 熟练掌握顺序表的基本算法：例如插入、删除、按值或按序号查找、输出等；并拓展一些操作算法，例如置逆、按值删除等；...数据结构与算法实验
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法——线性表（顺序表篇）
小田是个程序员的博客欢迎你的到来呀~
06-11 6452
线性表且最简单的一种数据结构， 一个线性表是n个数据元素的有限序列 。本篇文章主要详细解读了线性表的基本概念，以及线性表中顺序表的重点知识。详细分析了顺序表的基本操作，图文结合，易于理解。............
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法上机实验一 顺序表
迈微AI研习社 · 号主
12-09 4712
本次继续更新数据结构与算法这门课的上机实验，主要涉及顺序表这一数据结构。
数据结构与算法—顺序表
Han同学
10-12 5819
详细介绍了顺序表的各种功能，并通过函数实现。
数据结构与算法之Python实现——顺序表
weixin_62917800的博客
10-15 2876
一刷数据结构与算法后的感言。线性表的简单理解以及顺序表的简单实现
数据结构：两个顺序表合并算法
study_jiang_up的博客
11-16 9541
将a，b两个有序顺序表进行合并，放在c顺序表当中，并且要保证顺序表c仍然有序。
数据结构与算法——知识点总结
记录知识，学习分享
06-02 2万+
本文包含数据结构与算法主要的基本知识点，便于知识的梳理和回顾。 如需详细了解具体知识点请自行结合课本或者网上查阅。 目录 1、概述 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 1、概述 从 2、线性表 3、栈 4、队列 5、串 6、多维数组和广义表 7、树和二叉树 8、图 9、查找 10、排序 ...
数据结构与算法实验一——顺序表操作实验报告
m0_51393229的博客
11-07 1万+
第一章 实验目的 1．掌握线性表的顺序存储结构的表示和实现方法。 2．掌握顺序表基本操作的算法实现。 3．了解顺序表的应用。 第二章 实验环境 硬件环境要求： PC机（单机） 使用的软件名称、版本号以及模块： DEV C++、VS2010等。 第三章 实验内容 编写一个程序，实现顺序表的各种基本运算（假设顺序表的元素类型为char），并在此基础上设计一个主程序完成如下功能： （1）初始化顺序表L； （2）依次采用尾插法插入a、b、c、d、e元素； （3）输出顺序表L； （4）输出顺序表L的长度； （5）判断
数据结构与算法c++实现 删除顺序表中大于x的元素
06-04
数据结构与算法c++实现 删除顺序表中大于x的元素 可直接运行 适合初学数据结构与算法大二学生
数据结构与算法-顺序表的创建与操作
04-21
数据结构与算法实验，适用于计算机专业和通信专业，编程语言采用c++
数据结构与算法（一）顺序表的实现
07-04
顺序表的增删改查
JavaScript数据结构与算法之链表
10-22
链表就是线性表中针对顺序存储结构的一种优化手段，但是在javascript语言中由于数组的特殊性（自动更新引用位置），所以我们可以采用对象的方式做链表存储的结构
计算机408备考-数据结构重要知识点-数据结构的定义
Protinx的博客
05-02 303
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。数据结构包括三方面的内容：逻辑结构、存储结构和数据的运算。数据的逻辑结构和存储结构是密不可分的两个方面，一个算法的设计取决于所选定的逻辑结构，而算法的实现则依赖于所采用的存储结构。【计算机408备考-数据结构重要知识点-数据结构的定义-哔哩哔哩】
【高阶数据结构】并查集
m0_70088010的博客
05-05 329
并查集
数据结构——二叉树链式结构的实现(下)
weixin_74795859的博客
05-05 609
一般大家求高度的时候，都会这样去写代码，但这样写是有问题的，使用三目运算符使虽然让代码行数减少了，但造成了空间栈的浪费，因为在算左子树深度和右子树深度时，求出来的结果值只用在了判断它们俩谁大谁小的问题上面并没有保存返回值，当判断完左还是右大以后，后面运行的代码它还要再次去计算左子树或者右子树深度再+1，造成了重复计算(栈浪费)，如果是数据量大会造成栈溢出。解决办法就是创建变量接收左子树或者右子树的深度，再进行比较，这样就不会造成栈溢出的问题，也节省了空间和提高了效率。那么使用层序遍历是最好的。
数据结构-二叉树-二叉搜索树
最新发布
m0_67635008的博客
05-06 268
最大节点为最右节点，最小节点就是最左节点 ，还需要处理要删除的节点为根节点，它没有左子树或者没有右子树的情况。如果退化成下面的情况，插入删除的效率就变成了O(N)，所以我们引出了AVL树红黑树B树系列。3、两个孩子，需要进行替换，也就是替换法，用左子树的最大节点或者右子树的最小节点。若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。若它的左子树不为空，则左树上所有节点的值都小于根节点的值。依次删除7、14、3、8。3、8属于需要替换法进行删除的场景。二、查找、插入、删除。
数据结构与算法顺序表
09-06
在数据结构与算法中，我们可以使用顺序表来实现各种常见的算法，比如线性查找、二分查找、插入排序、选择排序等等。 线性查找是一种简单的查找算法，它从顺序表的第一个元素开始逐个比较，直到找到目标元素或者遍历...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

悦心无谓

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

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

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

打赏作者

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

抵扣说明：

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

余额充值