---

线性表概念

线性表是最基本、最简单、也是最常用的一种数据结构，常见的线性表:顺序表、链表、栈、队列、字符串…线性表（linear> list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
顺序表概念以及结构

顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表一般可以分为:
1.静态顺序表:使用定长数组存储。
2.动态顺序表:使用动态开辟的数组存储。

静态顺序表

概念：

静态顺序表就是给定存储数据的大小来存储数据，在运行时已经确定的了，一般都是通过一个固定大小的数组来储存元素

优点：

通过数组的下标就能够快速的找到相应的元素，有快速访问的效果

缺点

由于静态顺序表在开始时储存的空间大小已经确定了，无法改变，所以如果设置过大就会造成空间的浪费，如果太小就会造成数据溢出

实现：

1.我们通过静态的顺序表来实现增删
2.在实现我们的过程中每完成一个函数就验证一下，保证不会出错再实现下一个函数
3.我们要实现的函数有初始化、打印、判断数组空间是否已满、尾插、头插、尾删、头删

一.构建框架
1.通过多文件来链接

基本的头文件和创建的结构体和一些定义

#include<stdio.h>
#include<string.h>//用于初始化 memset函数
#include<stdlib.h>
#include <assert.h>//用assert函数-判断对错
#define  max 20   //方便改变数组的大小
typedef int SQDataType;//方便改变数据类型
struct SeqList     //创建结构体（由于结构体能放多种 不同的数据，
//我们这里就实现整数）{SQDataType a[max];//数组int size;//记录元素个数};
typedef  struct SeqList  sl;//简化

二.分模块实现
1.初始化
我们将结构体中的数组和元素个数都初始化为0
代码实现：

void SeqListInit(sl* ps) {memset(ps->a, 0, sizeof(SQDataType) * max);//将数组内容初始化为0ps->size=0;//开始拥有0个元素
}

检查：

2.判断数组是否已经满了
我们通过比较size（数组中元素的个数）和（max数组最大 容量）来判断
代码实现：

int man(sl* ps) {if (ps->size >= max)//当size大于max时此时数组空间已经满了{return 0;}elsereturn 1;
}

3.尾插
因为数组是从下标0开始的，所以我们可以将插入的数据插到数组下标为size（元素的个数）那个位置即可，由于插入一个数据，所以size要加1
代码实现：

void  SeqListPushBack(sl* ps, SQDataType x) {//尾插assert(man(ps));//判断数组空间是否满了ps->a[ps->size] = x;//赋值ps->size++;//下标++}

检查：
我们这里插入 1，2，3，4

4.打印
通过循环将结构体中的数组内容打印出来
代码实现：

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

检查：

5.头插
头插过程中我们要通过循环将所有数据都往后移动一位，再减插入的元素放到下标为0的位置即可，当然size也要加1哦
代码实现：

void SeqListPushFront(sl* ps, SQDataType x) {//头插assert(man(ps));for (int i =ps->size; i>0; i--) {//所有数据后移动一位ps->a[i] =ps->a[i-1] ;}ps->a[0] = x;ps->size++;
}

检查
我们在上面的基础上头插一个0

6.尾删
我们可以直接将数组最后一个赋为0（因为我们初始化本身就是0），当然size要减1
代码实现：

void SeqListPopBack(sl* ps) {//尾删ps->a[ps->size - 1] = 0;ps->size--;
}

检查：
在上面的基础上减去两个数

7.头删
我们可以直接通过循环直接将首元素直接覆盖
代码实现：

void SeqListPopFront(sl* ps) {//头删for (int i = 0; i < ps->size; i++)//所有数据前移动一位，将头个数据给覆盖掉ps->a[i] = ps->a[i + 1];ps->size--;//减少一个元素
}

检查：
在上面的基础上头删两个数据

所有代码一览：
SeqList.h:

```c
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>//用于初始化 memset函数
#include<stdlib.h>
#include <assert.h>//用assert函数-判断对错
#define  max 20   //方便改变数组的大小
typedef int SQDataType;//方便改变数据类型
struct SeqList     //创建结构体{SQDataType a[max];int size;//记录元素个数};
typedef  struct SeqList  sl;//简化
// 增删查改等接口函数
void SeqListInit(sl* ps);//初始化
int man(sl* ps);//判断数组是否已满
void SeqListPrint(sl* ps);//打印
//   尾插  头插 尾删  头删
void SeqListPushBack(sl* ps, SQDataType x);//尾插
void SeqListPushFront(sl* ps, SQDataType x);//头插
void SeqListPopBack(sl* ps);//尾删
void SeqListPopFront(sl *ps);//头删

SeqList.c:

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"
void SeqListInit(sl* ps) {memset(ps->a, 0, sizeof(SQDataType) * max);//将数组内容初始化为0ps->size=0;//开始拥有0个元素
}
void SeqListPrint(sl* ps) {//打印for (int i = 0; i < ps->size; i++)printf("%d ", ps->a[i]);printf("\n");
}
int man(sl* ps) {if (ps->size >= max)//当size大于max时此时数组空间已经满了{return 0;}elsereturn 1;
}void  SeqListPushBack(sl* ps, SQDataType x) {//尾插assert(man(ps));//判断数组空间是否满了ps->a[ps->size] = x;//赋值ps->size++;//下标++}void SeqListPushFront(sl* ps, SQDataType x) {//头插assert(man(ps));for (int i =ps->size; i>0; i--) {//所有数据后移动一位ps->a[i] =ps->a[i-1] ;}ps->a[0] = x;ps->size++;
}
void SeqListPopBack(sl* ps) {//尾删ps->a[ps->size - 1] = 0;ps->size--;
}
void SeqListPopFront(sl* ps) {//头删for (int i = 0; i < ps->size; i++)//所有数据前移动一位，将头个数据给覆盖掉ps->a[i] = ps->a[i + 1];ps->size--;//减少一个元素
}

Test.c:

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"
void teat1() {sl s;SeqListInit(&s);SeqListPushBack(&s, 1);SeqListPushBack(&s, 2);SeqListPushBack(&s, 3);SeqListPushBack(&s, 4);SeqListPushFront(&s, 0);SeqListPopBack(&s);SeqListPopBack(&s);SeqListPopFront(&s);SeqListPopFront(&s);SeqListPrint(&s);
}
int main() {teat1();return 0;
}

以上就是静态顺序表的增删实现了

动态顺序表

概念

动态顺序表可以根据需求来扩容存储空间，比静态顺序表灵活，因此动态顺序表被广泛使用

优点：

可以根据需要动态地分配内存,灵活性更高。 可以避免静态数组可能出现的内存浪费问题。
由于内存空间是动态分配的,因此可以处理数据量不确定或者变化的情况

缺点：

由于插入、删除数据时可能会移动大量数据，所以效率较低

实现：
动态顺序表和静态的过程差不多，就是将数组的空间大小改为可变的
1.在顺序表的基础上增加了扩容函数，不需要判断空间是否满的函数，初始化函数也改变了
2.用指针的方式将数据链接起来
一.改变的创建的结构体

struct SeqList {SQDataType* a;//用指针的方式将数据链接起来int size;//元素的个数int capacity;//空间的大小
};

二.主要函数的实现
1.初始化：

void SeqListInit(sl* ps) {ps->a = NULL;//将指针置空ps->size = 0;//开始为0ps->capacity = 0;//空间开始为0
}

检查：

2.扩容：

void SeqListCheckCapacity(sl* ps) {if (ps->size == ps->capacity) {//判断空间是否满了，满了就扩容int ws = ps->capacity == 0 ? 4 : 2 * ps->capacity;//如果空间为0就先给4不然就给2倍SQDataType* tmp = (SQDataType*)realloc(ps->a, sizeof(SQDataType) * ws);//扩容，将首地址给tmpif (tmp == NULL)//判断是否成功扩容{printf("realloc fail\n");exit(-1);}else{ps->a = tmp;//将首地址给aps->capacity = ws;//将扩容后的空间大小赋给capacity}}
}

3.尾插
因为数组是从下标0开始的，所以我们可以将插入的数据插到数组下标为size（元素的个数）那个位置即可，由于插入一个数据，所以size要加1
代码实现：

void  SeqListPushBack(sl* ps, SQDataType x) {//尾插SeqListCheckCapacity(ps);//判断是否要扩容ps->a[ps->size] = x;//赋值ps->size++;//下标++}

检查：
我们这里插入 1，2，3，4

4.打印与静态顺序表一样
5.头插
头插过程中我们要通过循环将所有数据都往后移动一位，再减插入的元素放到下标为0的位置即可，当然size也要加1哦
代码实现：

void SeqListPushFront(sl* ps, SQDataType x) {//头插SeqListCheckCapacity(ps);for (int i =ps->size; i>0; i--) {//所有数据后移动一位ps->a[i] =ps->a[i-1] ;}ps->a[0] = x;ps->size++;
}

检查：
我们在上面的基础上头插一个0


6.由于尾删和头删没有涉及到扩容，所以和静态顺序表的一样

总结

1.还有查改等没写，有兴趣的可以去试试哦
2.顺序表虽然可以通过扩容来解决空间问题，但是每次以2倍的增长时，还是会造成一定的空间浪费，如：我扩了100个空间，我只用了10个。
3.就是顺序表在插入或者删除时，需要移动大量的数据，这样导致效率不高

以上就是我的分享了，如果有什么错误，欢迎在评论区留言。
最后，谢谢大家的观看！