顺序表的理解与与实现

一、顺序表

1.概念及结构

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

顺序表一般分为两种：
1.静态顺序表：使用定长数组储存数据

#define N 7
typedef int SLDataType;

typedef struct SepList
{
    SLDataType  array[N];
    size_t size;
}SepList;

2.动态顺序表：使用动态开辟的数组储存

//动态开辟数组
typedef struct SepList
{
    SLDataType * array;
    size_t size;  //有效数据的个数
    size_t capicity; //容量空间的大小
}SeqList;

2.动态顺序表的接口实现

静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空
间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间
大小，所以下面我们实现动态顺序表。

1.顺序表动态存储的结构

typedef int SLDataType;
// 顺序表的动态存储
typedef struct SeqList
{
  SLDataType* array;  // 指向动态开辟的数组
  size_t size ;       // 有效数据个数
  size_t capicity ;   // 容量空间的大小
}SeqList;

2.顺序表的初始化

void SeqListInit(SeqList* psl)
{
    psl->array = NULL;
    psl->capicity = psl->size = 0;
}

刚开始未储存数据时系统未分配内存空间给顺序表，所以动态开辟的数组置为空，空间容量和有效数据个数自然为0。

3.顺序表的打印

> void SeqListPrint(SeqList* psl)
{
    for (int i = 0; i < psl->size; i++)
    {
        printf("%d ", psl->array[i]);
    }
    printf("\n");
}

4.顺序表的检查函数

void CheckCapacity(SeqList* psl)
{
    if (psl->size == psl->capicity)
    {
        int newcapicity = psl->capicity = 0 ? 4 : psl->capicity * 2;
        SLDataType* tmp = (SLDataType*)realloc(psl->array, newcapicity * sizeof(SLDataType));
        if (tmp == NULL)
        {
            perror("realloc:");
            return;
        }
        psl->array = tmp;
        psl->capicity = newcapicity;
    }

}

顺序表的检查函数检查内存空间大小是否足够，如果不够就使用realloc进行增容

6.顺序表的销毁

void SeqListDestory(SeqList* psl)
{
    if (psl)
    {
        free(psl);
        psl->array = NULL;
        psl->capicity = psl->size = 0;
    }
}

7.顺序表的尾插

// 顺序表尾插
void SeqListPushBack(SeqList* psl, SLDataType x)
{
    CheckCapacity(psl);
    psl->array[psl->size] = x;
    psl->size++;
}

顺序表的尾插只需要检查一下内存空间是否充足，然后直接插入

8.顺序表的尾删

// 顺序表尾删
void SeqListPopBack(SeqList* psl)
{
    psl->size--;
}

这里只需要将有效数据个数减一就可以实现，因为当下次写入时会覆盖掉上一次的数据

9.顺序表的头插

// 顺序表头插
void SeqListPushFront(SeqList* psl, SLDataType x)
{
    CheckCapacity(psl);
    int tmp = psl->size;
    while (tmp >= 1)
    {
        psl->array[tmp] = psl->array[tmp - 1];
        tmp--;
    }
    psl->array[0] = x;
    psl->size++;
}

10.顺序表的头删

// 顺序表头删
void SeqListPopFront(SeqList* psl)
{
    assert(psl->size);
    int tmp = 1;
    while (tmp < psl->size)
    {
        psl->array[tmp - 1] = psl->array[tmp];
        tmp++;
    }
    psl->size--;
}

11.顺序表的查找

// 顺序表查找
int SeqListFind(SeqList* psl, SLDataType x)
{
    for (int i = 0; i < psl->size; i++)
    {
        if (psl->array[i] == x)
        {
            return i;
        }
    }
    return -1;
}

12.顺序表在任意位置插入

// 顺序表在pos位置插入x
void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
{
    assert(psl);
    assert(pos >= 0 && pos < psl->size);
    CheckCapacity(psl);
    int tmp = psl->size;
    while (tmp >= pos)
    {
        psl->array[tmp] = psl->array[tmp - 1];
        tmp--;
    }
    psl->array[pos] = x;
    psl->size++;
}

13.顺序表在任意位置删除

// 顺序表删除pos位置的值
void SeqListErase(SeqList* psl, size_t pos)
{
    assert(psl);
    assert(pos >= 0 && pos < psl->size);
    int tmp = pos + 1;
    while (tmp < psl->size)
    {
        psl->array[tmp - 1] = psl->array[tmp];
        tmp++;
    }
    psl->size--;
}