数据结构与算法——顺序表
目录
前言
顺序表结构
结构定义
顺序表的实现
初始化
检查容量判断是否需要扩容
头插
头删
尾插
尾删
指定数据位置插入
指定数据删除
寻找数据并返回下标
销毁顺序表
源码
顺序表小结
前言
在介绍顺序表之前我们先简单了解一下线性表：
线性表是n个具有相同特性的数据元素的有限序列，在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
常见的线性表：顺序表、链表、栈、队列、字符串...
顺序表结构
顺序表就是采用数组存储，但在数组的基础上，要从头部开始存储且是连续存储，中间不能跳跃
顺序表也分为动态顺序表和静态顺序表。我们下面实现动态顺序表
静态顺序表：使用定长的数组存储，给定的空间是固定的，也可以理解为你申请了一个房间的空间，你只能在这个房间使用空间。由于不灵活这里就直接介绍动态的
动态顺序表：采用动态开辟的数组存储，可以灵活的使用空间，空间不够可以realloc扩容。可以理解为你开始申请了一个房间，而当你整个房间的空间用完后，你可以再申请一个房间的空间使用。如果有不了解动态内存分配的可以小伙伴，可以看看我之前写的动态内存分配
结构定义
由于是动态内存分配，我们需要定义一个结构体：
1.存放一个指针用来维护动态内存开辟的空间
2.存放变量size，记录存放的个数
3.存放变量capacity，记录当前空间的容量，空间满了就扩容
typedef int DataType;
typedef struct SeqList
{
DataType* p;
int sz;
int capacity;
}SL;
顺序表的实现
初始化
我们先创建一个结构体变量 SL s，然后传变量s的地址通过一系列的接口函数实现顺序表的增删查改。首先要先初始化s，将p置空，sz和capacity置0。
SL s;
SeqListInit(&s);
void SeqListInit(SL* pc)
{
pc->sz = pc->capacity = 0;
pc->p = NULL;
}检查容量判断是否需要扩容
定义一个check函数判断空间是否满了，如果满了就扩容，为避免频繁扩容我们每次扩2倍，比如100字节的空间扩容为200字节的空间。当插入数据时，首先需要调用check函数判断容量是否满了
对realloc函数，如果要扩容的空间为NULL时，会当成malloc函数使用，所以我们直接使用realloc
void SeqListCheckCapacity(SL* pc)
{
//没有空间则扩容
if (pc->sz == pc->capacity)
{
int newcapacity = pc->capacity == 0 ? 4 : pc->capacity * 2;
DataType* tmp = (DataType*)realloc(pc->p, newcapacity * sizeof(DataType));
if (tmp == NULL)
{
printf("%s\n", strerror(errno));
exit(-1);
}
pc->p = tmp;
pc->capacity = newcapacity;
}
}然后就是顺序表的头插pushfront，头删popfront，尾插pushback，尾删popback，指定pos位置插入pushpop，destory销毁等，顺序表的源码
尾插，尾删直接插入删除，头插，头删需要挪动数据后插入删除
头插
假定当前的容量capacity是8，sz已经存放的个数是4，而我们要头插数据5的话，就要把顺序表整体后移，然后插入5，此时数据增加了一个，sz就要++，
对指针p，p[tmp]等价于 *(p+tmp)
void SeqListpushfront(SL* pc, DataType x)
{
SeqListCheckCapacity(pc);
int tmp = pc->sz;
while (tmp > 0)
{
pc->p[tmp] = pc->p[tmp - 1];
--tmp;
}
pc->p[0] = x;
pc->sz++;
}
头删
头删与头插类似，不过是向左挪动数据删除顺序表中的第一个数据，但是当顺序表没有数据时就不能头删了，所以我们要assert断言一下，断言为真程序就继续，为假就会报错了，涉及指针大部分需要断言
void SeqListpopfront(SL* pc)
{
assert(pc->sz > 0);
int tmp = 1;
while (tmp < pc->sz)
{
pc->p[tmp - 1] = pc->p[tmp];
++tmp;
}
pc->sz--;
}尾插
尾插只需要在当前顺序表的最后一个数据后面插入，当然插入数据时首先要check容量
void SeqListpushback(SL* pc, DataType x)
{
SeqListCheckCapacity(pc);
pc->p[pc->sz] = x;
pc->sz++;
}尾删
先断言顺序表是否有数据支持删除
void SeqListpopback(SL* pc)
{
assert(pc->sz > 0);
pc->sz--;
}指定数据位置插入
和头插类似找到数据后挪动后面的数据再插入即可，这里的pos表示顺序表中的第几个数
void SeqListInsert(SL* pc, DataType x, int pos)
{
SeqListCheckCapacity(pc);
assert(pos <= (pc->sz+1) && pos > -1); //pos表示第几个数，不是下标索引
int tmp = pc->sz;
while (pos <= tmp + 1)
{
pc->p[tmp] = pc->p[tmp - 1];
tmp--;
}
pc->p[pos - 1] = x;
pc-> sz++;
}指定数据删除
那我们只需找到这个数，然后通过左移删除即可
void SeqListErase(SL* pc, int pos)
{
assert(pos <= pc->sz && pos > -1);
while (pos <= pc->sz)
{
pc->p[pos - 1] = pc->p[pos];
pos++;
}
pc->sz--;
}寻找数据并返回下标
遍历顺序表找到后返回下标，找不到就返回-1
int SeqListFind(SL* pc, DataType x)
{
for (int i = 0; i < pc->sz; i++)
{
if (pc->p[i] == x)
return i;
}
return -1;
}销毁顺序表
因为我们是在堆区动态开辟的空间，不用了就要free释放空间避免内存泄漏，并将sz和capacity置0
void SeqListDestory(SL* pc)
{
pc->sz = 0;
pc->capacity = 0;
free(pc->p);
pc->p = NULL;
}源码
SeqList.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"
void SeqListInit(SL* pc)
{
pc->sz = pc->capacity = 0;
pc->p = NULL;
}
void SeqListCheckCapacity(SL* pc)
{
//没有空间则扩容
if (pc->sz == pc->capacity)
{
int newcapacity = pc->capacity == 0 ? 4 : pc->capacity * 2;
DataType* tmp = (DataType*)realloc(pc->p, newcapacity * sizeof(DataType));
if (tmp == NULL)
{
printf("%s\n", strerror(errno));//errno是错误码,strerror()根据错误码判断出错原因
exit(-1);//扩容失败后就直接退出程序了
}
pc->p = tmp;
pc->capacity = newcapacity;
}
}
void SeqListPrint(SL* pc)
{
for (int i = 0; i < pc->sz; i++)
{
printf("%d\t", pc->p[i]);
}
printf("\n");
}
void SeqListpushback(SL* pc, DataType x)
{
SeqListCheckCapacity(pc);
pc->p[pc->sz] = x;
pc->sz++;
}
void SeqListpopback(SL* pc)
{
assert(pc->sz > 0);
pc->sz--;
}
void SeqListpushfront(SL* pc, DataType x)
{
SeqListCheckCapacity(pc);
int tmp = pc->sz;
while (tmp > 0)
{
pc->p[tmp] = pc->p[tmp - 1];
--tmp;
}
pc->p[0] = x;
pc->sz++;
}
void SeqListpopfront(SL* pc)
{
assert(pc->sz > 0);
int tmp = 1;
while (tmp < pc->sz)
{
pc->p[tmp - 1] = pc->p[tmp];
++tmp;
}
pc->sz--;
}
void SeqListDestory(SL* pc)
{
pc->sz = 0;
pc->capacity = 0;
free(pc->p);
pc->p = NULL;
}
void SeqListInsert(SL* pc, DataType x, int pos)
{
SeqListCheckCapacity(pc);
assert(pos <= (pc->sz+1) && pos > -1); //pos表示第几个数，不是下标索引
int tmp = pc->sz;
while (pos <= tmp + 1)
{
pc->p[tmp] = pc->p[tmp - 1];
tmp--;
}
pc->p[pos - 1] = x;
pc-> sz++;
}
void SeqListErase(SL* pc, int pos)
{
assert(pos <= pc->sz && pos > -1);
while (pos <= pc->sz)
{
pc->p[pos - 1] = pc->p[pos];
pos++;
}
pc->sz--;
}
int SeqListFind(SL* pc, DataType x)
{
for (int i = 0; i < pc->sz; i++)
{
if (pc->p[i] == x)
return i;
}
return -1;
}
Test.c
#include "SeqList.h"
void Test2()
{
SL s;
SeqListInit(&s);
SeqListpushback(&s, 1);
SeqListpushback(&s, 2);
SeqListpushback(&s, 3);
SeqListpushback(&s, 4);
SeqListpushback(&s, 5);
SeqListPrint(&s);
SeqListInsert(&s, 10, 6);
SeqListPrint(&s);
SeqListErase(&s, 1);
SeqListPrint(&s);
printf("%d\n", SeqListFind(&s, 10));
printf("%d\n", SeqListFind(&s, 20));
SeqListDestory(&s);
}
int main()
{
//Test1();
Test2();
}SeqList.h
#pragma once
#include
#include
#include
#include
typedef int DataType;
typedef struct SeqList
{
DataType* p;
int sz;
int capacity;
}SL;
//顺序表初始化
void SeqListInit(SL* pc);
//检查顺序表的容量
void SeqListCheckCapacity(SL* pc);
//顺序表尾插
void SeqListpushback(SL* pc, DataType x);
//顺序表尾删
void SeqListpopback(SL* pc);
//顺序表头插
void SeqListpushfront(SL* pc, DataType x);
//顺序表头删
void SeqListpopfront(SL* pc);
//打印顺序表
void SeqListPrint(SL* pc);
//删除顺序表
void SeqListDestory(SL* pc);
//顺序表指定pos位置插入
void SeqListInsert(SL* pc, DataType x, int pos);
// 删除pos位置的数据
void SeqListErase(SL* pc, int pos);
// 找到了返回x位置下标，没有找到返回-1
int SeqListFind(SL* pc, DataType x); 顺序表小结
顺序表也是有缺陷的：
1️⃣空间不够时需要扩容的，而扩容是需要付出代价的，我们一般是扩2倍，这也从一定程度上导致空间浪费，（比如我只需要120的空间，而100的空间满了，扩容为200，导致80的空间浪费）且原空间不够扩容的话，需要将数据全部迁移，大大降低了效率。
2️⃣顺序表是从头开始且连续存储数据的，而当我们要在头部或是中间位置插入删除数据时，需要挪动数据，也大大降低了效率。
当然顺序表也不是一无是处的，顺序表空间是连续有序的，支持随即访问，有很多程序都要支持随机访问
针对顺序表的这两个缺陷又引入了链表，之后会给大家介绍链表以及链表的实现。
不是看到希望才去坚持，而是坚持了才看到希望，敬每一位努力奋斗的你和学习编程的你。希望我的文章能对你有所帮助。欢迎点赞 ，评论，关注，⭐️收藏
