【数据结构】顺序表 超详细！

已于 2024-05-09 22:20:29 修改
阅读量1.1k 收藏 10
点赞数 34
文章标签： 算法 c语言 visualstudio 数据结构
于 2024-01-29 23:38:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79499548/article/details/135923189
版权

目录

一.顺序表定义

1 、顺序表的概念及结构

1.1线性表

2、顺序表分类

2.1 静态顺序表

2.2 动态顺序表

二、动态顺序表的实现 ( 重要！)

1.准备工作及其注意事项

1.1 先创建三个文件

1.2 注意事项：帮助高效记忆和理解

2.顺序表的基本功能接口

2.0 创建一个 顺序表

2.1 顺序表的初始化

2.2 顺序表的销毁

2.3 顺序表的打印

3.顺序表的扩容检查接口

4.顺序表的增加功能接口

4.1 尾插接口

4.2 头插接口

4.3 指定位置插入接口

5.顺序表的删除功能接口

5.1 尾删接口

5.2头删接口

5.3指定位置删除接口

6.顺序表的查找实现接口

三.总代码

SeqList.h

SepList.c

test.c

一.顺序表定义

1 、顺序表的概念及结构

1.1线性表

线性表（linearlist）是n个具有相同特性的数据元素的有限序列。

线性表是一种在实际中广泛使  用的数据结构，常⻅的线性表：顺序表、链表、栈、队列、字符串...  

线性表在逻辑上是线性结构，也就说是连续的一条直线。

但是在物理结构上并不一定是连续的，  线性表在物理上存储时，通常以数组和链式结构的形式存储。  简单来说顺序表是线性表的一种,而且逻辑和物理都是线性结构

2、顺序表分类

顺序表和数组的区别

◦ 顺序表的底层结构是数组，对数组的封装，实现了常用的增删改查等接口
2.1 静态顺序表
概念：使用定长数组存储元素
静态顺序表缺陷：空间给少了不够用，给多了造成空间浪费
 静态顺序表(这里拿里面存储的整形举例)
 typedef int SLDataType;
 #define N 100
 typedef struct SeqList
 {
     SLDatatype arr[N];
     int size;//size是有效数据的个数
 }SL;
  
 解释一下为什么要把存储的类型变为SLDataType
 这么做是为了方便以后修改 使用 不同 的类型 
 还有把数组存储的数据容量N 便于修改
2.2 动态顺序表

前言：

动态顺序表的结构更加灵活, 可以对结构进行 增删查改，所以我们下面的接口都是通过动态顺序表实现的

二、动态顺序表的实现(重要！)

1.准备工作及其注意事项

1.1 先创建三个文件

 解释这三个文件的作用
 1、头文件SeqList.h  是来声明接口函数，定义顺序表，将几个公共用到的库函数集合起来
 2、源文件SeqList.c  是用来具体实现接口
 3、源文件test.c  用于接口的测试工作 ，即具体的使用场景

1.2 注意事项：帮助高效记忆和理解
 1.不管写任意一种接口函数，我们在处理之前都要进行断言，避免穿过来的是NULL指针  assert(ps->arr) ;
 2.在进行扩容操作 的时候别忘记了 realloc要将新空间的地址和容量 更新给 自己的数组 和 容量变量(在下文)
 3.进行插入操作之后  要把size++;  在进行删除操作的时候要进行size--;(很重要的一点)
 4、插入操作 和 删除操作 用到循环 数据整体后移 或 前移 一定要注意 边界！！！

2.顺序表的基本功能接口

2.0 创建一个 顺序表
//动态顺序表
typedef int SLDataType;// 定义一个 类型名字，方便快速修改 类型
typedef struct SeqList
{
	SLDataType* arr;
	int capacity; // 记录动态顺序表 申请空间的大小 
	int size;// 记录 顺序表 当前有效的数据个数
}SL;
// 给 结构体命名，翻遍方便使用：直接写在下面也可以
// typedef struct SeqList SL;
2.1 顺序表的初始化
void SLInit(SL* ps)
{
	assert(ps);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}
2.2 顺序表的销毁
void SLDestroy(SL* ps)
{
	assert(ps);
	free(ps->arr);
	ps->arr = NULL;
	ps->capacity = ps->size = 0;
}
2.3 顺序表的打印
// 打印顺序表：这里可以 传值 也可 传址 ，
// 因为不需要对数据进行修改(可以传值)，但是 为了保持接口一致性(其他接口都是传址)，这里直接使用 传址
void SLPrint(SL* ps)
{
	for (int i = 0; i < ps->size; ++i) printf("%d ", ps->arr[i]);
	printf("\n");
}

3.顺序表的扩容检查接口

// 公共的扩容判断
void SLCheckCapacity(SL* ps)
{
	//当容量capacity 大小 == 标记点size 时，说明 已经满了：需要 扩容
	if (ps->size == ps->capacity)
	{
		// 开辟空间时注意，当capacity初始化为 0 时，直接相乘的结果还是 0 ！！
		// 所以要先判断一下, 并且需要做 申请空间是否成功的判断，
        // 还不能直接将申请的空间赋值给 目标数组，先给一个 临时变量
		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity; 
        // 每次 两倍空间扩容(tip：这里推荐2倍的倍数扩容，可以自行查找为什么倍数扩容 较好！)
		SLDataType* ptmp = (SLDataType*)realloc(ps->arr, newCapacity * sizeof(SLDataType));
		if (ptmp == NULL)
		{
			perror("realloc fail!");
			exit(1);
		}
		// 扩容成功
		ps->arr = ptmp;
		ps->capacity = newCapacity;
	}
}

4.顺序表的增加功能接口

4.1 尾插接口
// （1）尾插法：有三种情况：1) 头部非空，尾部还有空间；2)全部为空；3)全部满了
void SLPushBack(SL* ps, SLDataType x)
{
	// 先判断指针是否非空
	assert(ps);
	// 空间不够，扩容 : 3）
	SLCheckCapacity(ps);
	// 空间足够，直接插入：1 ) ; 2 )
	// 在 size 这个位置插入数据: size 是标记第一个空位置
	ps->arr[ps->size++] = x;
	// ps->size++; // 标记点size 需要即使更新：size++ 也可以合并在上面
}
4.2 头插接口
// 头插法
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps);
	// 空间不够，扩容 : 3）
	SLCheckCapacity(ps);

	// 将数据向后挪动：注意边界问题！！！
	for (int i = ps->size; i > 0; --i) ps->arr[i] = ps->arr[i - 1];
	
	ps->arr[0] = x; // 将插入数据 放在头部
	ps->size++; // 别忘 了 更新 size
}
4.3 指定位置插入接口
// 指定位置之前插入数据
void SLInsert(SL* ps, int pos, SLDataType x)
{
	assert(ps);
	// 注意 ： 可以指定位置插入 说明 指定的位置pos 可能不合理，可能越界, 必须要断言判断一下
	assert(0 <= pos && pos < ps->size); // 注意 不能等于 size！！！！
	// 判断是否有足够的空间
	SLCheckCapacity(ps);

	// 在 pos 位置中 插入 数据 x ：就要将 pos 位置 起的 后面数据向后挪动
	for (int i = ps->size; i >= pos + 1; --i) // 让 pos 这个位置 空出来
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++;
}

5.顺序表的删除功能接口

5.1 尾删接口
void SLPopBack(SL* ps)
{
	// 删除前 检查：顺序表非空才能执行删除，同时 size 不能为 0
	assert(ps);
	assert(ps->size);// 顺序表不为空
	ps->size--; 
    // 直接 size-- 将 size 位置的数值 丢出 我们的有效数据空间，那个位置不属于有效空间了，则类似达到删除的效果
}
5.2头删接口
void SLPopFront(SL* ps)
{
	// 删除前 检查：顺序表非空才能执行删除，同时 size 不能为 0
	assert(ps);
	assert(ps->size);
    
	// 将 后面的 数据 向前移动： 注意边界！！
	for (int i = 1; i < ps->size; ++i) ps->arr[i - 1] = ps->arr[i];
	ps->size--;
}
5.3指定位置删除接口
void SLErase(SL* ps, int pos)
{
	assert(ps);
	// 注意 ： 可以指定位置插入 说明 指定的位置可能不合理，可能越界, 必须要断言判断一下
	assert(0 <= pos && pos < ps->size); // 注意 不能等于 size
	for (int i = pos + 1; i < ps->size; ++i)
	{
		ps->arr[i - 1] = ps->arr[i];
	}
	ps->size--;
}

6.顺序表的查找实现接口

int SLFind(SL* ps, int x)
{
	for (int i = 0;i < ps->size;++i)
	{
		if (ps->arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}

三.总代码

SeqList.h

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

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

// 一、初始化
void SLInit(SL* ps);

// 二、 尾插法
void SLPushBack(SL* ps, SLDataType x);

// 二、 头插法
void SLPushFront(SL* ps, SLDataType x);

// 三、尾删法
void SLPopBack(SL* ps);

// 四、头删法
void SLPopFront(SL* ps);

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

// 六、指定位置插入
void SLInsert(SL* ps, int pos, SLDataType x);

//顺序表的扩容检查(扩容的原则,以及扩容的方法)
void SLCheckCapacity(SL* ps);

// 打印函数
void SLPrint(SL* ps);

SepList.c

#include"SeqList.h"


void SLInit(SL* ps)
{
	ps->arr = NULL;
	ps->Capacity = ps->size = 0;
}

// 开辟空间函数
void SLCheckCapacity(SL* ps)
{
	if (ps->size == ps->Capacity)
	{
		int NewCapacity = ps->Capacity == 0 ? 4 : 2 * (ps->Capacity);
		SLDataType* ptmp = realloc(ps->arr, NewCapacity * sizeof(SLDataType));
		if (ptmp == NULL)
		{
			perror("realloc fail !");
			exit(1);
		}
		ps->arr = ptmp;
		ps->Capacity = NewCapacity;
	}
}
// 二、 尾插法
void SLPushBack(SL* ps, SLDataType x)
{
	// 先判断指针是否非空
	assert(ps); // 别忘了
	// 分两大类情况：空间足够 和 空间不够
	// (1) 空间不够：空间扩展
	SLCheckCapacity(ps);
	// 开始尾插
	ps->arr[ps->size++] = x;
}

// 二、 头插法
void SLPushFront(SL* ps, SLDataType x)
{
	assert(ps); // 别忘了
	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);
	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 SLErase(SL* ps, int pos)
{
	assert(ps);
	assert(0 <= pos && pos < ps->size);
	for (int i = pos; 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(0 <= pos && pos < ps->size);
	SLCheckCapacity(ps);
	for (int i = ps->size; i >= pos + 1; --i)
	{
		ps->arr[i] = ps->arr[i - 1];
	}
	ps->arr[pos] = x;
	ps->size++; // 别忘记了
}

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

test.c

#include"SeqList.h"
void slTest01()
{
	SL sl;  // 创建一个结构体变量 sl
	SLInit(&sl); // 这里需要 传地址：才能真正被初始化

	//测试尾插
	SLPushBack(&sl, 1);
	SLPushBack(&sl, 2);
	SLPushBack(&sl, 3);
	SLPushBack(&sl, 4); // ctrl + d == ctrl + c + v
	printf("测试尾插: ");
	SLPrint(&sl);

	// 测试头插
	SLPushFront(&sl, 10);
	printf("测试头插: ");
	SLPrint(&sl);

	// 测试 尾删
	SLPopBack(&sl);
	printf("测试尾删: ");
	SLPrint(&sl);

	// 测试 头删
	SLPopFront(&sl);
	printf("测试头删: ");
	SLPrint(&sl);

	// 测试 指定位置插入
	SLInsert(&sl, 1, 15);
	printf("指定插入: ");
	SLPrint(&sl);

	SLErase(&sl, 1);
	printf("指定删除: ");
	SLPrint(&sl);
}
int main()
{
	slTest01(); // 第一个测试函数
	return 0;
}

四、顺序表的问题及思考

问题：

1. 中间/头部的插⼊删除，时间复杂度为O(N)

2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不⼩的消耗。

3. 增容⼀般是呈2倍的增⻓，势必会有⼀定的空间浪费。例如当前容量为100，满了以后增容到 200，我们再继续插⼊了5个数据，后⾯没有数据插⼊了，那么就浪费了95个数据空间。

思考：如何解决以上问题呢？

有没有 这样一个 数据结构

1、中间 和 头尾的 数据插入 不用 挪动 其他数据，而是一步到位

2、不需要直接扩充连续的空间（用不完容易浪费，像上面第 3 点所说）

3、不会造成空间浪费

这样的强大的数据结构 即为  【 链表 】

可以 点击跳转 讲解 单链表 的实现文章  ---->：【数据结构】单链表的实现

完。

若上述文章有什么错误，欢迎各位大佬及时指出，我们共同进步！

时差freebright
关注
  • 34
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
编写一个完整顺序表的程序
10-14
（1） 建立一个顺序表，含有n个数据元素。 （2） 输出顺序表及顺序表的长度。 （3） 在顺序表给定的位置i，插入一个值为x的结点。 （4） 在顺序表中删除值为x的结点或者删除给定位置i的结点。 （5） 将顺序表逆置，将结果保存到另外的顺序表中。 （6） 将顺序表按升序排序。 （7） 将两个顺序有序表A和B合并为一个有序表C。 （8） 在主函数中设计一个简单的菜单，分别测试上述算法。
超详细的顺序表（附源码）
weixin_73397765的博客
10-14 230
顺序表是线性表的一种，代码量对于前面的学习，有明显的难度。小编也是第一次学习数据结构，如有谬误，欢迎指正。本篇收录于《数据结构杂谈》中。
数据结构_day02_顺序表
zzugsh的博客
04-06 129
顺序表顺序表基本概念顺序表的基本形式顺序表的结构和实现顺序表的结构顺序表中的两种基本实现方式元素存储区替换元素存储区扩充顺序表的操作增加元素删除元素Python中的顺序表list的基本实现技术 顺序表 基本概念 程序中，经常需要将一组(通常为某个类型的)数据元素作为整体管理和使用，需要创建这种元素组，用变量记录他们，传进传出函数等。 一组元素数据中包含的元素个数可能发生变化 比如说可以增加或者删除...
用C语言编写一个完整的程序,实现顺序表的建立、插入、删除、输出等基本运算。
qq_44471975的博客
04-06 7677
#include<stdio.h> #include<stdlib.h> #define maxsize 30 typedef int datatype; typedef struct seqlist{ datatype data[maxsize]; int n; }seqlist; struct seqlist L; //顺序表初始化1-20 void Stu() { p...
顺序表基本操作（完整）
Moralin_的博客
03-21 3026
Seqlist.h#define _CRT_SECURE_NO_WARNINGS 1 #pragma once #include&lt;stddef.h&gt; #define SeqlistMaxsize 100 typedef char SeqlistType; typedef struct Seqlist{ SeqlistType data[SeqlistMaxsize]; size...
超详细讲解数据结构之顺序表
bit_xwg的博客
03-15 2583
超详细讲解数据结构之顺序表顺序表概念静态顺序表动态顺序表动态循序表的概念及构造动态顺序表接口的实现检查顺序表的容量尾插与尾删头插与头删 顺序表 概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。 顺序表一般分为静态顺序表和动态顺序表。 静态顺序表 静态顺序表是使用定长数组存储元素。 简单静态顺序表结构体的初始化： #define N 7 typedef int SLDataType; struct Seqlist { SLDataTy
【数据结构】顺序表的实现——超级无敌详细
qq_59702185的博客
08-07 1988
在当我们每想插入一个数据的时候，我们都要对顺序表进行判断，容量 capacity 是否和 size 相等，如果相等的话，那么，顺序表的空间就不够我们进行插入数据了。当然我们不能需要插入一个数据就开辟一个数据的大小，这样的话，付出的代价很大，我们可以每次增容 2 倍的capacity大小的容量，或者4倍，2倍是比较好的了。在我们想把顺表表最后一个数据删除时，不能直接赋为0，第一，我们不知道SLDataType到底是什么数据类型，第二，顺序表的最后一个数据有可能就是0，没有意义。遍历一遍顺序表，打印顺序表。..
数据结构顺序表和链表（超详细）
08-14
此压缩包为1、无头+单向+非循环链表增删查改实现// 动态申请一个结点// 单链表打印// 单链表尾插// 单链表的头插// 单链表的尾删// 单链表头删// 单链表查找// 单链表在pos位置之后插入x// 单链表删除pos位置之后的...
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
基于Python实现的数据结构与算法完整源代码+超详细注释(包含46个作业项目).zip
01-02
基于Python实现的数据结构与算法完整源代码+超详细注释(包含46个作业项目) 项目包含： 01_变位词问题 02_python数据类型的性能 03_python实现ADT Stack 04_栈的应用1括号匹配 05_栈的应用2十进制转二进制 06_栈的...
数据结构各种结构动画演示
04-10
数据结构各种结构动画演示（珍藏，精品） 很适应于数据结构初学者，直观易懂 二叉排序树的生成.swf 串的顺序存储.swf 单链表结点的插入.swf 单链表结点的插入.swf 邻接表表示的图的广度优先遍历.swf 等等。。。 绝对...
文章编辑系统数据结构课程设计
09-16
数据结构课程设计报告用的 文章编辑系统 超全的
顺序表的简单实现--完整版
TingMind的博客
04-27 1109
修改了之前写的顺序表的实现，完善了一下功能，完全原创，欢迎小伙伴交流
1.线性表的顺序存储结构————顺序表（包含C语言和C++版本的完整程序）
热门推荐
隔壁老王的博客
08-13 1万+
1.顺序表的定义 2.顺序表的基本操作 3.顺序表的编程实现 3.1 C++实现顺序表 3.2 C语言实现顺序表 3.3 测试结果 1.顺序表的定义    将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构，采用顺序存储结构的线性表简称为“ 顺序表”。    顺序表的存储特点是：只要确定了起始位置，表中任一元素的地址都通过下列公式得到： Loc(ai)=Loc(...
乘法逆元算法
2302_81590667的博客
05-22 608
有些云里雾里的那个取正整数的地方，好多地方都是公式推理和验证定理的正确性，看不懂，初等数论再说！乘法逆元的意思就是给出两个数a，b如果a，b互质（就是两个数的最大公约数是1）那么就有。1(mod 5)，x=2,7,12.....x的每个值都差5；可以用费马小定理来推导乘法逆元我就不细讲了想知道可以看这个博客。这个题必须用scanf和printf要不然超时。就是必有a*x%b==1；
BERT系列算法解读
qq_52053775的博客
05-19 209
从而提高模型在SQuAD、MNLI和SST-2数据集上的性能。总的来看，这些优化措施显著增强了模型的表现。
【力扣一轮】454.四数之和 && 383.赎金信
诚。
05-22 279
为什么能想到这里，注意到它的和是0，（和可以是任何数）这样就相当于两两数组为一对，看其中一对数组中的元素，在另外一对数组中是否出现了相反数。这里的一对说的是A+B或其他组合方式，（不重要，因为都是随机的）然而以上想法截止到第二句，都没问题，需要注意的是，不是全对应。A2：因为在存储时，不仅要存储对应的元素，也要存储元素出现的次数，所以用到map。结合之前的有效字母异位符，数组，set，map，使用数组即可。也就是说如果一对数组中有两个-2，另一对数组中只有一个2，那么计算为0的次数为2。
每日一题（PTA Advanced1003）：Emergency-dfs
m0_75015083的博客
05-22 185
【代码】每日一题（PTA Advanced1003）：Emergency-dfs。
每周一算法：Prim算法求最小生成树
最新发布
少儿编程乔老师
05-23 989
在一个无向图中求边权和最小的生成树，即无向连通图的最小生成树（Minimum Spanning Tree，MST）。本文介绍使用Prim算法求最小生成树。
王道数据结构栈的链式存储
08-26
在王道数据结构书中，可能会对链式存储结构的实现进行详细的介绍，包括节点的定义、插入和删除操作的具体步骤等。如果你需要更详细的信息，建议参考相关章节的内容。<span class="em">1 #### 引用[.reference_title]...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值