顺序表解析

已于 2024-03-16 13:30:14 修改
阅读量824 收藏 23
点赞数 16
分类专栏： 数据结构 文章标签： c语言 数据结构
于 2024-03-16 13:22:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78310843/article/details/136660540
版权
本文详细介绍了顺序表的概念，包括线性表和静态/动态顺序表的区别。重点讲解了动态顺序表的实现，包括初始化、尾部插入、头部插入、删除、查找和销毁等操作。
摘要由CSDN通过智能技术生成

目录

1. 顺序表的概念及结构

1.1 线性表

2. 顺序表分类 

2.1 顺序表分类

 2.1.1 静态顺序表

 2.1.2 动态顺序表

3. 动态顺序表的实现

创建动态顺序表：

 实现初始化：

尾部插入：

头部插⼊：

尾部删除：

头部删除：

在指定位置之前插入数据：

删除指定位置数据：

查找：

销毁：

最终代码集合：

1. 顺序表的概念及结构

1.1 线性表

最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。

线性表在逻辑上是线性结构，也就是说是连续的一条直线。但是在物理上并不一定是连续的，线性表在物理上存储是，通常是以数组和链式结构的形式进行存储。

而顺序表属于线性表的一种，顺序表的逻辑结构是线性的，物理结构是连续的。

2. 顺序表分类 

顺序表和数组的区别：

  顺序表的底层是数组，对数组的封装，实现了常用的增、删、改、查 等接口。 

2.1 顺序表分类

结合数组的相关知识可以类比出：

给定长度的数组：     int arr[10]       ——————    静态顺序表

动态设置数组长度： int* arr            ——————    动态顺序表

 2.1.1 静态顺序表

使用定长数组存储元素。

//静态顺序表
struct SeqList
{
	int arr[100];  //100 指的是开辟了100个整型大小的空间，不代表有100个有效的数据
	int size;      //有效数据的个数
}SL;

 

缺点：静态顺序表的空间开的不够用，会导致后续的数据保存失败。

 2.1.2 动态顺序表

可增容，按需申请

//动态顺序表
struct SeqList
{
	int* arr;  //存储数据的底层结构
	int capacity;     //记录顺序表的空间大小
	int size;         //记录顺序表当前有效数据的个数
};

3. 动态顺序表的实现

首先新建项：SeqList.h   SeqList.c   test.c

SeqList.h：定义顺序表的结构，顺序表要实现的接口/方法
SeqList.c：具体实现顺序表里定义的接口/方法

test.c：测试顺序表

创建动态顺序表：

SeqList.h：

#define N 100
typedef int SLDataType;
//动态顺序表
typedef struct SeqList
{
	SLDataType* arr;
	int capacity;
	int size;
}SL;

 实现初始化：

初始化：

（1）假设所定义的函数传递的是值，那么有：

//SeqList.h
void SLInit(SL s);//这里传的是值

//SeqList.c
void SLInit(SL s)
{
	s.arr = NULL;
	s.size = s.capacity = 0;
}

//test.c  测试传值的可行性
void slTest01()
{
	SL sl;
	SLInit(sl);
}
int main()
{
	slTest01();
	return 0;
}

结果： 

形参是实参的一份临时拷贝，sl 没有初始化，无法将值传给 s，就无法进行拷贝。所以传值是不可行的。

（2） 假设所定义的函数传递的是地址，那么有：

//SeqList.h
//初始化
void SLInit(SL* ps);
//SeqList.c
//初始化
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

尾部插入：

首先，尾插有三种情况：

像第一种和第二种，空间足够，直接插入。第三种中的空间不够，就需要扩容。


 

//SeqList.h
//尾部插入
void SLPushBack(SL* ps, SLDataType x);

//SeqList.c
//尾部插入
void SLPushBack(SL* ps, SLDataType x)
{
	//空间不够，扩容
	if (ps->size == ps->capacity)
	{
		int ncapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, ncapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = ncapacity;
	}


	//空间足够，直接插入
	ps->arr[ps->size] = x;
	ps->size++;
}

使用 SLPrint()函数测试尾插：

假如传一个NULL，那么：

乱七八糟的退出码，所以是不能传空的。所以就需要进行判断。

因为空间扩容这部分在后面的头部插入也会用到，所以这部分可以再定义一个函数，最后的简化结果为：

//SeqList.h

//尾部插入
void SLCheckCapacity(SL* ps);
void SLPushBack(SL* ps, SLDataType x);

void SLPrint(SL* ps);

//SeqList.c

//扩容操作
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int ncapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, ncapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = ncapacity;
	}
}

//尾部插入
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps != NULL);
	//空间不够，扩容
	SLCheckCapacity(ps);

	//空间足够，直接插入
	ps->arr[ps->size] = x;
	ps->size++;
}

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

头部插⼊：

同样的，头部插入主要分成两种情况：

而数据的挪动需要从后往前。

//SeqList.h

//头部插入
void SLCheckCapacity(SL* ps);
void SLPushFront(SL* ps, SLDataType x);

//SeqList.c

//头部插入
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps != NULL);
	//空间不够，扩容
	SLCheckCapacity(ps);

	//空间足够，将旧数据往后挪动
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

测试头插： 

尾部删除：

尾部删除分成两种情况：

//SeqList.h

//尾部删除
void SLPopBack(SL* ps);

//SeqList.c

//尾部删除
void SLPopBack(SL* ps) {
	assert(ps != NULL);
	assert(ps->size);

	//顺序表不为空
	ps->size--;
}

测试尾删：

头部删除：

头部删除分为两种情况：

//SeqList.h

//头部删除
void SLPopFront(SL* ps);

//SeqList.c

//头部删除
void SLPopFront(SL* ps) {
	assert(ps);
	assert(ps->size);

	//不为空
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

测试头删：

在指定位置之前插入数据：

//SeqList.h

//指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x);

//SeqList.c

//指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x) {
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);

	//pos及之后的数据往后挪动一位，pos空出来
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

删除指定位置数据：

同样的道理：

//SeqList.h

//删除指定位置数据
void SLErase(SL* ps, int pos);

//SeqList.c

//删除指定位置数据
void SLErase(SL* ps, int pos) {
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	//pos以后的数据往前挪动一位
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

查找：

//SeqList.h

//在顺序表中查找X
int SLFind(SL* ps, SLDataType x);

//SeqList.c

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

测试查找：

销毁：

到了顺序表收尾的阶段了。当顺序表不使用了，就要对顺序表进行销毁，该初始化的初始化，释放空间。

//SeqList.h

//销毁
void SLDestroy(SL* ps);

//SeqList.c

//销毁
void SLDestroy(SL* ps) {
	assert(ps);

	if (ps->arr) {
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

最终代码集合：

//SeqList.h

#pragma once

//定义顺序表的结构，顺序表要实现的接口/方法

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

//静态顺序表

#define N 100
//
//struct SeqList
//{
//	SLDataType a[N];
//	int size;
//};

//动态顺序表

typedef int SLDataType;

//struct SeqList
//{
//	SLDataType* arr;  //存储数据的底层结构
//	int capacity;     //记录顺序表的空间大小
//	int size;         //记录顺序表当前有效数据的个数
//}SL;
//
//typedef struct SeqList SL;

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

//初始化 / 销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps);

//尾部插入 / 头部插入
void SLCheckCapacity(SL* ps);
void SLPushBack(SL* ps, SLDataType x);
void SLPushFront(SL* ps, SLDataType x);

//尾部删除 / 头部删除
void SLPopBack(SL* ps);
void SLPopFront(SL* ps);

//指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x);

//删除指定位置数据
void SLErase(SL* ps, int pos);

//在顺序表中查找X
int SLFind(SL* ps, SLDataType x);

//SeqList.c

#include "SeqList.h"
//具体实现顺序表里定义的接口/方法

//初始化
void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

//扩容操作
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->capacity)
	{
		int ncapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		SLDataType* tmp = (SLDataType*)realloc(ps->arr, ncapacity * sizeof(SLDataType));
		if (tmp == NULL)
		{
			perror("realloc!");
			exit(1);
		}
		ps->arr = tmp;
		ps->capacity = ncapacity;
	}
}

//尾部插入
void SLPushBack(SL* ps, SLDataType x)
{
	assert(ps != NULL);
	//空间不够，扩容
	SLCheckCapacity(ps);

	//空间足够，直接插入
	ps->arr[ps->size] = x;
	ps->size++;
}

//头部插入
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps != NULL);
	//空间不够，扩容
	SLCheckCapacity(ps);

	//空间足够，将旧数据往后挪动
	for (int i = ps->size; i > 0; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[0] = x;
	ps->size++;
}

//尾部删除
void SLPopBack(SL* ps)
{
	assert(ps != NULL);
	assert(ps->size);

	//顺序表不为空
	ps->size--;
}

//头部删除
void SLPopFront(SL* ps)
{
	assert(ps);
	assert(ps->size);

	//不为空
	for (int i = 0; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

//指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	assert(pos >= 0 && pos <= ps->size);

	SLCheckCapacity(ps);

	//pos及之后的数据往后挪动一位，pos空出来
	for (int i = ps->size; i > pos; i--)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

//删除指定位置数据
void SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(pos >= 0 && pos < ps->size);

	//pos以后的数据往前挪动一位
	for (int i = pos; i < ps->size - 1; i++)
	{
		ps->arr[i] = ps->arr[i + 1];
	}
	ps->size--;
}

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

//销毁
void SLDestroy(SL* ps) 
{
	assert(ps);

	if (ps->arr) {
		free(ps->arr);
	}
	ps->arr = NULL;
	ps->size = ps->capacity = 0;
}

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

YMLT花岗岩
关注
  • 16
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
顺序表 AB取交集
03-26
根据给定的信息，本文将详细解释“顺序表 AB取交集”的实现原理及相关代码细节。 ### 一、顺序表的基本概念 在数据结构中，**顺序表**是一种基本的线性表存储结构，其特点是利用一组地址连续的存储单元依次存放...
实用算法实验_顺序表的应用
11-10
首先，逐行读取指定文件中的数据，并进行解析后保存在顺序表中。其中，文件中每行数据格式为“学号,姓名,年龄”，比如“SA10225048,[yyw1] 张三,24”。 （提示：采用顺序表结构时，顺序表中每个表元素包含三类信息...
shunxubiao.rar_遍历顺序表
09-21
以上是对“shunxubiao.rar_遍历顺序表”相关知识点的详细解析。实际应用中，顺序表因其简单易用的特性，常被用作基础的数据存储结构。shunxubiao.txt文件可能是包含这些操作示例代码的文本文件，通过阅读和理解代码...
顺序表插入删除
11-03
### 顺序表插入删除知识点详解 #### 一、顺序表基本概念 在计算机科学中，顺序表是一种常用的数据结构，其特点是数据元素在内存中连续存放。本实验通过一个简单的C语言程序实现了顺序表的基本操作——插入和删除，...
C语言顺序表
12-10
在计算机科学中，顺序表是一种基本的数据结构，它在内存中按照线性顺序存储元素。在C语言中，实现顺序表通常涉及动态内存分配和数组操作。本文将深入探讨C语言顺序表的相关知识点，包括其定义、实现方式、操作及优...
CF961（div2）a-c
m0_74310050的博客
07-25 881
题意：有n*n的棋盘，有k个筹码，将这些筹码放在棋盘上，对角线指i+j值相同的，求被占对角线的最少数目分析:除了第n条对角线只有一条，从1到n-1都有两条代码：int n,k;cin>>n>>k;ll ans=0;else{k-=n;ans++;else{i>=1;i--){ans++;k-=i;ans++;k-=i;int t;cin>>t;return 0;
2024华为OD机试真题- 亲子游戏-(C++/Java/Python)-C卷D卷-200分
goldarmour的博客
07-24 5197
​宝宝和妈妈参加亲子游戏，在一个二维矩阵（N*N）的格子地图上，宝宝和妈妈抽签决定各自的位置，地图上每个格子有不同的糖果数量，部分格子有障碍物。游戏规则是妈妈必须在最短的时间（每个单位时间只能走一步）到达宝宝的位置，路上的所有糖果都可以拿走，不能走障碍物的格子，只能上下左右走。
R语言的cbind和rbind如何区分
weixin_69556916的博客
07-24 471
m行的矩阵与n行的矩阵rbind()最后变成m+n行，合并前提：rbind(a, b)中矩阵a、b的列数必需相符。，m列的矩阵与n列的矩阵cbind()最后变成m+n列，合并前提：cbind(a, b)中矩阵a、b的行数必需相符。在R语言中，我们可以利用函数cbind() 和rbind() 把向量和矩阵拼成一个新的矩阵。cbind（列方式）： 把矩阵横向合并成一个大矩阵，根据列进行合并，即。rbind（行方式）： 纵向合并，根据行进行合并，就是。
【C语言】用队列实现栈
2301_80840905的博客
07-25 203
leetcode题目：用两个队列实现一个栈【C语言】
2.4GHz射频前端集成芯片：AT2401C芯片中文资料
YHPsophie的博客
07-25 244
AT2401C是采用CMOS工艺实现的单芯片器件，其内部集成了功率放大器(PA)，低噪声放大器(LNA)，芯片收发开关控制电路，输入输出匹配电路以及谐波滤波电路。由于该芯片有高性能，高灵敏度和效率，低噪声，产品尺寸小以及低成本，使得AT2401C对于频率带宽内的应用而言成为完美的解决方案。AT2401C是一款面向Zigbee，无线传感网络以及其他2.4GHz频段无线系统的全集成射频功能的射频前端单芯片。AT2401C的功能控制逻辑电路非常简单，而且使用了少量的外围器件，可以非常方便系统的整体集成设计。
【C语言】数组
weixin_74076508的博客
07-24 1107
C语言中，我们可以创建一个变量，用来存储数据，但如果我们想存储多个数据时，怎么办呢？我们就可以使用来存储多个数据。接下来我们来一起学习 数组 这一节课吧！
大话C语言：第32篇 指针数组
whccf的博客
07-25 370
指针数组是一种数组，其每个元素都是一个指针。指针数组是一种特殊的数组，其元素是指针而非实际的数据值。每个指针元素可以指向相同或不同类型的对象，这取决于程序需要。指针数组通常用于存储指向一系列对象的指针，这些对象可以是变量、数组、函数等。
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 359
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
【数据结构】单链表的增删改查
2302_78914800的博客
07-25 766
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
c语言（7.23）
fhgfyrsg的博客
07-23 652
【代码】c语言（7.23）
《Java初阶数据结构》----7.＜优先级队列PriorityQueue＞
最新发布
m0_73456341的博客
07-25 843
本篇博客主要讲解Java基础语法中的 优先级队列、PriorityQueue的特性、常用方法介绍、编程题练习
数据结构：顺序表的实现
2303_81073778的博客
07-25 281
3.test.c文件。
数据结构：（1）线性表
weixin_71751116的博客
07-24 1070
概念：零个或多个数据元素的有限序列元素之间是有顺序了。如果存在多个元素，第一个元素无前驱最后一个没有后继其他的元素只有一个前驱和一个后继。当线性表元素的个数n（n>=0）定义为线性表的长度，当n=0时，为空表。在非空的表中每个元素都有一个确定的位置，如果a1是第一个元素，那么an就是第n个元素。线性表的常规操作 ADTchar sex;int age;int score;}DATATYPE;//数组名int tlen;
EXT4 数据结构
弥川的博客
07-25 343
结构 ext4_inode 实际使用的超出最初 128 字节 ext2 inode 的字节数记录在每个 inode 的 i_extra_isize 字段中，这使得结构 ext4_inode 可以在新内核中增长，而无需升级所有磁盘上的 inode。ext4 开始，flex_bg 中几个块组被捆绑在一起作为一个 逻辑块组，bitmap 空间和 inode Table 空间 flex_bg 的第一个块组被扩展为包括位图以及 flex_bg 中所有其他块组的 inode 表。没有 inode 0。
C++线性表入门：顺序表与链表解析
线性表有两种主要的存储方式：顺序存储（顺序表）和链式存储（链表）。顺序存储利用连续的内存空间存储元素，而链式存储则通过指针链接元素。顺序存储便于随机访问，但插入和删除操作可能涉及大量元素的移动。链式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

YMLT花岗岩

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

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

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

打赏作者

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

抵扣说明：

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

余额充值