数据结构·一篇搞定顺序表！

大家好啊，几日不见，甚是想念，从这一篇文章开始，我们就要进入数据结构了哦，那么我们废话不多说，今天我们一起来搞定顺序表！！！
请添加图片描述

1. 顺序表概念及结构

顺序表是一种线性结构，它由一组连续的存储单元（通常是数组）组成，数据元素之间的关系是相邻的。顺序表中的元素是按照一定的顺序排列的，可以通过下标来访问和操作各个元素。顺序表的结构简单、易于实现，是一种常见的数据结构之一。

2. 顺序表分类

• 顺序表和数组的区别
◦ 顺序表的底层结构是数组，对数组的封装，实现了常⽤的增删改查等接口

静态顺序表

#define MAX_SIZE 10

typedef struct {
    int data[MAX_SIZE];
    int length;
} StaticList;

在这个例子中，我们定义了一个包含10个整数元素的静态顺序表，其中data数组存储元素，length表示当前顺序表中元素的个数。在使用静态顺序表时，需要注意不要超出预先定义的最大长度，否则可能导致数组越界错误.

动态顺序表

在这里插入图片描述
我们一般使用顺序表都是动态顺序表，这样的话才可以进行增删改查的操作，那么我们接下来就来康康这些操作~

3. 实现动态顺序表

#define INIT_CAPACITY 4
typedef int SLDataType;
// 动态顺序表 -- 按需申请
typedef struct SeqList
{
 SLDataType* a;
 int size; // 有效数据个数
 int capacity; // 空间容量
}SL;
//初始化和销毁
void SLInit(SL* ps);
void SLDestroy(SL* ps);
void SLPrint(SL* ps);
//扩容
void SLCheckCapacity(SL* ps);
//头部插⼊删除 / 尾部插⼊删除
void SLPushBack(SL* ps, SLDataType x);
void SLPopBack(SL* ps);
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);
//指定位置之前插⼊/删除数据
void SLInsert(SL* ps, int pos, SLDataType x);
void SLErase(SL* ps, int pos);
int SLFind(SL* ps, SLDataType x);

下面是实现的代码

#define INIT_CAPACITY 4  
  
typedef int SLDataType;  
  
typedef struct SeqList {  
    SLDataType* a;  
    int size; // 有效数据个数  
    int capacity; // 空间容量  
} SL;

3.1 初始化

// 初始化  
void SLInit(SL* ps) {  
    ps->a = (SLDataType*)malloc(INIT_CAPACITY * sizeof(SLDataType));  
    if (!ps->a) {  
        exit(EXIT_FAILURE); // 分配内存失败  
    }  
    ps->size = 0;  
    ps->capacity = INIT_CAPACITY;  
}

通过 malloc 函数为顺序线性表的数组成员 a 分配内存空间，大小为 INIT_CAPACITY *
sizeof(SLDataType)，其中 INIT_CAPACITY 是一个预先定义的常量，表示初始容量。
检查内存分配是否成功，如果分配失败（即 ps->a 为 NULL），则调用 exit(EXIT_FAILURE)
函数退出程序。
将顺序线性表的 size 成员初始化为 0，表示当前表中没有元素。
将顺序线性表的 capacity 成员初始化为INIT_CAPACITY，表示表的初始容量为 INIT_CAPACITY。

3.2 销毁

void SLDestroy(SL* ps) {  
    free(ps->a);  
    ps->a = NULL;  
    ps->size = 0;  
    ps->capacity = 0;  
}

调用 free 函数释放顺序线性表的数组成员 a 所占用的内存空间，这样可以避免内存泄漏。
将顺序线性表的 a 成员指针设置为 NULL，这是一种良好的习惯，可以避免出现野指针访问的问题。
将顺序线性表的 size 成员设为 0，表示表中不再有元素。
将顺序线性表的 capacity 成员设为 0，表示表的容量为 0。

3.3 打印

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

这个没什么好说的吧哈哈哈

3.4 扩容

void SLCheckCapacity(SL* ps) {  
    if (ps->size == ps->capacity) {  
        ps->capacity *= 2;  
        SLDataType* temp = (SLDataType*)realloc(ps->a, ps->capacity * sizeof(SLDataType));  
        if (!temp) {  
            exit(EXIT_FAILURE); // 扩容失败  
        }  
        ps->a = temp;  
    }  
}

判断顺序线性表的当前大小（size）是否等于容量（capacity），如果相等，则表示表中元素已经填满，需要进行扩容操作。
将顺序线性表的容量 capacity 扩大为原来的两倍，即 ps->capacity *= 2;，这里采用了简单的扩容策略。
调用 realloc 函数重新分配内存空间，将原来的数据拷贝到新的空间中，大小为 ps->capacity *
sizeof(SLDataType)。
检查是否成功分配新的内存空间，如果分配失败（即 temp 为 NULL），则调用 exit(EXIT_FAILURE)
函数退出程序。
将新分配的内存空间的地址赋值给顺序线性表的数组成员 a，完成扩容操作。

3.5 头部插入

void SLPushFront(SL* ps, SLDataType x) {  
    SLCheckCapacity(ps);  
    for (int i = ps->size; i > 0; i--) {  
        ps->a[i] = ps->a[i - 1];  
    }  
    ps->a[0] = x;  
    ps->size++;  
}

调用 SLCheckCapacity 函数，确保顺序线性表有足够的容量来存储新的元素。
从顺序线性表的最后一个元素开始，依次将元素向后移动一个位置，为新元素腾出空间。这里使用循环从 ps->size
开始，依次向前移动元素，直到第一个元素。
将要插入的新元素 x 放入顺序线性表的第一个位置，即头部位置。
增加顺序线性表的大小 size，表示表中元素数量增加了一个。

3.6 头部删除

void SLPopFront(SL* ps) {  
    if (ps->size == 0) {  
        return;  
    }  
    for (int i = 0; i < ps->size - 1; i++) {  
        ps->a[i] = ps->a[i + 1];  
    }  
    ps->size--;  
}

判断顺序线性表的大小（size）是否为0，如果是空表（size == 0），则直接返回，不进行删除操作。
从顺序线性表的第一个元素开始，依次将元素向前移动一个位置，覆盖掉原来的元素。这里使用循环从0开始，依次向后移动元素，直到倒数第二个元素。
减少顺序线性表的大小 size，表示表中元素数量减少了一个。

3.7 尾部插入

void SLPushBack(SL* ps, SLDataType x) {  
    SLCheckCapacity(ps);  
    ps->a[ps->size] = x;  
    ps->size++;  
}

调用 SLCheckCapacity 函数，确保顺序线性表有足够的容量来存储新的元素。
将要插入的新元素 x 放入顺序线性表当前大小（size）的位置，即在尾部插入。
增加顺序线性表的大小 size，表示表中元素数量增加了一个。

3.8 尾部删除

不用说吧~~~

void SLPopBack(SL* ps) {  
    if (ps->size == 0) {  
        return;  
    }  
    ps->size--;  
}

3.9 指定位置之前插入数据

void SLInsert(SL* ps, int pos, SLDataType x) {  
    if (pos < 0 || pos > ps->size) {  
        return; // 插入位置不合理  
    }  
    SLCheckCapacity(ps);  
    for (int i = ps->size; i > pos; i--) {  
        ps->a[i] = ps->a[i - 1];  
    }  
    ps->a[pos] = x;  
    ps->size++;  
}

判断插入位置 pos 是否合理，即必须满足 pos >= 0 且 pos <= ps->size，否则直接返回，不进行插入操作。
调用 SLCheckCapacity 函数，确保顺序线性表有足够的容量来存储新的元素。
从顺序线性表的最后一个元素开始，依次将元素向后移动一个位置，为新元素腾出空间。这里使用循环从 ps->size开始，依次向前移动元素，直到插入位置 pos。
将要插入的新元素 x 放入顺序线性表的指定位置 pos。
增加顺序线性表的大小 size，表示表中元素数量增加了一个.

3.10 指定位置删除数据

void SLErase(SL* ps, int pos) {  
    if (pos < 0 || pos >= ps->size) {  
        return; // 删除位置不合理  
    }  
    for (int i = pos; i < ps->size - 1; i++) {  
        ps->a[i] = ps->a[i + 1];  
    }  
    ps->size--;  
}

判断删除位置 pos 是否合理，即必须满足 pos >= 0 且 pos < ps->size，否则直接返回，不进行删除操作。
从指定位置 pos 开始，将后面的元素依次向前移动一个位置，覆盖掉要删除的元素。这里使用循环从 pos
开始，依次将元素向前移动，直到倒数第二个元素。
减少顺序线性表的大小 size，表示表中元素数量减少了一个，相当于删除了一个元素。

3.11 查找数据

int SLFind(SL* ps, SLDataType x) {  
    for (int i = 0; i < ps->size; i++) {  
        if (ps->a[i] == x) {  
            return i; // 返回数据下标  
        }  
    }  
    return -1; // 没有找到数据  
}

4. 基于动态顺序表实现通讯录项目

相信大家掌握了上面的操作后，实现通讯录并不是啥难事，肖恩在这也不细细讲解了，希望大家理解哦~~~ 请添加图片描述

由于这个通讯录的代码有一点点多，放在这里大家也不好学习，我直接放个链接吧，大家直接点开就欧克了，也方便copy.
通讯录

5. 顺序表经典算法

这是两个有关顺序表的经典的算法的，大家点开链接可以做做，同样，我把代码放在这，大家自行悟道
经典算法OJ题1：移除元素

int removeElement(int* nums, int numsSize, int val) {
        int i, j;
    for(i = 0, j = 0; i < numsSize; i++){
        if(nums[i] != val){
            nums[j] = nums[i];
            j++;
        }
    }
    return j;
}

经典算法OJ题2：合并两个有序数组

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
int p1 = m - 1;
    int p2 = n - 1;
    int p = m + n - 1;
    
    while(p1 >= 0 && p2 >= 0){
        if(nums1[p1] > nums2[p2]){
            nums1[p] = nums1[p1];
            p1--;
        } else {
            nums1[p] = nums2[p2];
            p2--;
        }
        p--;
    }
    
    while(p2 >= 0){
        nums1[p] = nums2[p2];
        p2--;
        p--;
    }
}