【本篇内容】

1. 线性表

2. 顺序表

1. • 线性表

线性表是n个具有相同特性的数据元素的有限序列。常见的线性表：顺序表、链表、栈、队列、字符串......

线性表在逻辑上是线性结构，但是在物理结构上并一定是连续的，线性表在物理上存储时，通常是以数组和链式结构的形式存储的

2. • 顺序表

2.1概念及结构

顺序表是用一段物理地址连续的存储单元存储数据元素的线性结构，一般采用数组存储。在数组上完成数据的增删查改（要求数据连续存储）

顺序表一般可以分为：静态顺序表和动态顺序表

• 静态顺序表：使用定长数组存储元素

#pragma once
//静态顺序表
#define N 20
typedef int SLDataType;
typedef struct SeqList
{
    SLDataType a[N];
    int size;//记录存储多少个有效数据
}SL;

数据结构是一块用来存放数据，另一块是一些函数对数据进行一些操作

1. 用typedef重新命名结构体类型的原因

举个例子，如果我们需要对数据进行初始化我们肯定需要写一个函数来对数据进行初始化

void SeqList(struct SeqList s);

struct SeqList是结构体类型，用typedef重新定义为之后，相较之前更加简洁，并且使用struct SeqList过程中，初学者很容易将struct遗忘，所以习惯上我们会将结构体类型重新命名

2. 用typedef重新命名数据类型的原因

上面存储的数据是int类型，只能存储int类型的数据，但是顺序表可以存储任意类型的数据，所以重新命名一下数据类型，这样我们想要存储什么类型的数据就存储什么类型的数据，不用到各个函数的内部进行修改

静态顺序表在实际的使用中并不太常用，它开辟的空间是固定的

假设我们定义数组的空间是1000个，而我们实际只需要存储10个数据，其余的空间全部都被浪费了，此时我们又想用它存储2000个数据，这个空间又不够用

总结：

顺序表的缺点：

• 开少了可能不够用

• 开多了可能浪费

• 动态顺序表：使用动态开辟数组来存储

typedef int SLDataType;
typedef struct SeqList
{
    SLDataType* a;
    int size;//有效数据
    int capacity;//空间容量大小（每次扩容的数目）
}SL;

动态顺序表--按需开辟空间

这里动态内存开辟用realloc，realloc开辟的空间用没了，需要进行扩容，如果满了之后，每次只扩容一个空间，这样每次想要使用空间都需要进行扩容，这显然有些不合适，所以在扩容的时候，我们一次就多扩容些

2.2接口函数的实现

SeqList.h放结构体的定义函数的声明
SeqList.c函数的实现
Test.c测试用例

我们每次写完一个接口函数就要调试一下看跟自己的预期一样吗，不要将所有的接口函数都写完了再进行调试，不然你会发现一堆错误

以下接口函数中的参数都是用结构体指针，这里的接口函数都需要对结构体进行修改，在C语言中我们学习过形参的改变不会影响实参，所以在主函数中使用接口函数必须传递地址，并且接口函数在接收的时候使用指针的形式

🙆SeqList.h

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDataType;
typedef struct SeqList
{
    SLDataType* a;
    int size;//有效数据个数
    int capacity;//容量
}SL;

//初始化
void SLInit(SL* s);
//打印
void SLPrint(SL* s);
//扩容
void SLCheckCapacity(SL* s);
//销毁
void SLDestroy(SL* s);
//尾插
void SLPushBack(SL* s,SLDataType x);
//尾删
void SLPopBack(SL* s);
//头插
void SLPushFront(SL* s, SLDataType x);
//头删
void SLPopFront(SL* s);
//中间的插入
void SLInsert(SL* s,int pos, SLDataType x);
//中间的删除
void SLErase(SL* s,int pos);
//查找某一个元素，并且返回它的下标
int SLFind(SL* s,SLDataType x);

🙆SeqList.c

#define _CRT_SECURE_NO_WARNINGS
#include"SeqList.h"
//初始化
void SLInit(SL* s)
{
    s->a = NULL;
    s->size = 0;
    s->capacity = 0;
}
//打印
void SLPrint(SL* s)
{
    assert(s);

    for (int i = 0; i < s->size; i++)
    {
        printf("%d ", s->a[i]);
    }
    printf("\n");
}
//扩容
void SLCheckCapacity(SL* s)
{
    assert(s);
    if (s->size == s->capacity)
    {
        int newCapacity = s->capacity == 0 ? 4 : s->capacity * 2;
        int* tmp = (SLDataType*)realloc(s->a, newCapacity * sizeof(SLDataType));
        if (tmp == NULL)
        {
            perror("realloc fail");
        }
        s->capacity = newCapacity;
        s->a = tmp;
    }
}
//销毁
void SLDestroy(SL* s)
{
    assert(s);
    s->a = NULL;
    s->capacity = 0;
    s->size = 0;
}

//尾插
void SLPushBack(SL* s, SLDataType x)
{
    assert(s);
    SLCheckCapacity(s);
    s->a[s->size] = x;
    s->size++;
}
//尾删
void SLPopBack(SL* s)
{
    assert(s);
    assert(s->size > 0);
    s->size--;
}
//头插
void SLPushFront(SL* s, SLDataType x)
{
    assert(s);
    SLCheckCapacity(s);
    int end = s->size - 1;
    while (end >= 0)
    {
        s->a[end + 1] = s->a[end];
        end--;
    }
    s->a[0] = x;
    s->size++;
}
//头删
void SLPopFront(SL* s)
{
    assert(s);
    assert(s->size > 0);
    int begin = 0;
    while (begin < s->size - 1)
    {
        s->a[begin] = s->a[begin +1];
        begin++;
    }
    s->size--;
}
//中间的插入
void SLInsert(SL* s, int pos, SLDataType x)
{
    assert(s);
    assert(pos <= s->size);
    assert(pos >= 0);
    SLCheckCapacity(s);
    int end = s->size - 1;
    while (end >= pos)
    {
        s->a[end + 1] = s->a[end];
        end--;
    }
    s->a[pos] = x;
    s->size++;
}
//中间的删除
void SLErase(SL* s, int pos)
{
    assert(s);
    assert(pos >= 0);
    assert(pos < s->size);
    int end = pos + 1;
    while (end < s->size)
    {
        s->a[end - 1] = s->a[end];
        end++;
    }
    s->size--;
}
//查找某一个元素，并且返回它的下标
int SLFind(SL* s, SLDataType x)
{
    assert(s);
    for (int i = 0; i < s->size; i++)
    {
        if (s->a[i] == x)
            return i;
    }
    return -1;
}

这里查找我们采用的是遍历，从前往后找，我们在C语言中学习过，二分查找会更快一些，这里为什么不用二分查找

顺序表的函数里一般是不提供二分查找的，二分查找是有条件的，使用二分查找的前提条件是有序的，而顺序表内的数据不一定是有序的，所以我们不使用二分查找，一般快速大量的查找也不会使用顺序表，我们会使用其他结构

😋删除某一个值

1. SLFind

2. SLErase

先查找这个值的位置，然后再根据所在位置再删除

void TestSeqList3()
{
    SL s3;
    SLInit(&s3);
    SLPushBack(&s3, 1);
    SLPushBack(&s3, 2);
    SLPushBack(&s3, 3);

    //删除某一元素的值
    int pos = SLFind(&s3, 2);
    SLErase(&s3, pos);
    SLPrint(&s3);

    SLDestroy(&s3);
    

}

int main()
{
    TestSeqList3();
    return 0;
}

😋删除某一个指定的值，并且含有多个相同的值

上面的函数只能删除其中一个值，假设我们想要删除顺序表中所有的3，这时该怎么办？

顺序表中还会提供一个接口函数

int SLFind(SL* ps,SLDataType x,int begin);

//begin查找x的起始位置

void TestSeqList3()
{
    SL s3;
    SLInit(&s3);
    SLPushBack(&s3, 1);
    SLPushBack(&s3, 2);
    SLPushBack(&s3, 3);
    SLPushBack(&s3, 3);
    SLPushBack(&s3, 4);
    SLPushBack(&s3, 5);
    SLPushBack(&s3, 3);

    int pos = SLFind(&s3, 3, 0);
    while (pos != -1)
    {
        SLErase(&s3, pos);
        pos = SLFind(&s3, 3, pos);
    }
    SLPrint(&s3);
   
    SLDestroy(&s3);
    

}

int main()
{
    TestSeqList3();
    return 0;
}