最详细的顺序表

顺序表

【本节目标】
1.线性表概念
2.顺序表实现

---

线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…

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

---

顺序表实现

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

顺序表一般可以分为：

1. 静态顺序表：使用定长数组存储。
2. 动态顺序表：使用动态开辟的数组存储。

//顺序表的静态存储
//静态的顺序表  --给少了不够用，给多了浪费，不能灵活控制

#define N 100
typedef int SLDataType;

typedef struct SeqList
{
    SLDataType array[N]; // 定长数组
    size_t size; // 有效数据的个数
}SeqList;

静态表的问题：给少了不够用，给多了用不着。
所以改成动态的👇

//动态顺序表
typedef struct SeqList
{
        SQDataType *a;//只想开辟空间的数组
        int size;//有效数据的个数
        int capacity;//容量空间的大小
}SL;

注意定义顺序表的几个地方：👇

#define MAX_SIZE 10 方便修改a[]的大小
typedef int SQDataType; 方便改变结构体中的类型

---

接口实现

现实中使用的大多都是动态顺序表，根据动态的分配空间大小，所以实现动态顺序表。

顺序表-初始化

//头文件中
void SeqListInit(SL* ps); //s  变量的名称

//源文件中
void SeqListInit(SL* ps)
{
        ps->a = NULL;
        ps->size = 0;
        ps->capacity = 0;
}

---

顺序表-打印

//函数声明
void SeqListPrint(SL* ps);

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

就是打印一个数组一样，从i=0开始遍历到整个数组的大小。

---

顺序表-动态扩容

如果遇到顺序表满的情况下，将会进行自动扩容。

//函数申明
void SeqListCheckCapacity(SL* ps);//扩容

//函数实现
void SeqListCheckCapacity(SL *ps)//扩容函数
{
        //满了就要扩容
        if (ps->size == ps->capacity){
               int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
               SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * 
sizeof(SQDataType));
               if (tmp == NULL){
                       printf("reallic fail\n");
                       exit(-1);
               }
               else{
                       ps->a = tmp;
                       ps->capacity = newcapacity;
               }
        }
}

定义一个newcapacity,如果capacity的空间是0，则给capacity一个初始空间，否则将扩容自身的2倍
如果开辟失败则返回 --> reallic fail

顺序表-销毁

//函数申明
void SeqListDestory(SL* ps);//销毁

//函数实现
void SeqListDestory(SL* ps)//销毁
{
        free(ps->a);
        ps->a = NULL;
        ps->capacity = ps->size = 0;
}

---

顺序表函数接口

顺序表-尾插

空间满了直接调用SeqListCheckCapacity函数；
尾插的实现，实际上就是把元素插入最后一个位置ps->size;
最后ps->size++;

//函数申明
void SeqListPushBack(SL* ps, SQDataType x);//尾插

//函数实现
void SeqListPushBack(SL* ps, SQDataType x)//尾插
{
        //满了就要扩容
        SeqListCheckCapacity(ps);
        ps->a[ps->size] = x;
        ps->size++;
}

---

顺序表-头插

同样的，先检查空间；
头插的原理就是：从顺序表最后一个元素开始依次往后挪动一个，然后将要插入的数X插入到顺序表头部（ps->a[0]）;
最后ps->size++;

//函数申明
void SeqListPushFront(SL* ps, SQDataType x);//头插

//函数实现
void SeqListPushFront(SL* ps, SQDataType x)//头插
{
        SeqListCheckCapacity(ps);
        //1.初始条件
        //2.结束条件
        //3.迭代条件
        int end = ps->size - 1;
        while(end>=0)
        {
               ps->a[end] = ps->a[end + 1];
               --end;
        }
        ps->a[0] = x;//插入的数给a[0]
        ps->size++;//插入一个数就要增加1
}

注意：
while循环的条件是 end>=0
每次–end;

---

顺序表-尾删

//函数申明
void SeqListPopBack(SL* ps);//尾删

//函数实现
void SeqListPopBack(SL* ps)//尾删
{
        assert(ps->size > 0);
        //ps->a[size]=ps->a[size-1];
        /*ps->size--;*/
        SeqListErase(ps, ps->size-1);
}

这里有2种方法：
①：将顺序表从倒数第二个元素依次往后移动，覆盖后一个元素的值；
ps->size–;

②：直接调用上面顺序表-销毁函数，指定 ps->size-1 位置的元素；

---

顺序表-头删

①：原理：将顺序表从第二个元素素覆盖到前一个元素以此类推；
②：也可以直接调用销毁函数；
直接上代码👇

//函数申明
void SeqListpopFront(SL* ps);//头删

//函数实现
void SeqListpopFront(SL* ps)//头删
{
        /*int start = 1;
        while (start < ps->size)
        {
              ps->a[start - 1] = ps->a[start];
              ++start;
        }
        ps->size--;*/
        
        SeqListErase(ps, 0);

---

顺序表-指定位置插入

先从顺序表最后一个元素开始，while循环到插入的位置停止
循环的过程中将pos以后的元素往后挪移一个位置

指针到达pos后，插入X，然后将ps->size＋1

//函数声明
void SeqListInsert(SL* ps, int pos, SQDataType x);


//函数实现
void SeqListInsert(SL* ps, int pos, SQDataType x)
{
        assert(pos < ps->size);//断言
        SeqListCheckCapacity(ps);//满了就开辟空间
        int end = ps->size - 1;
        while (end >= pos)
        {
               ps->a[end + 1] = ps->a[end];
               --end;
        }
        ps->a[pos] = x;
        ps->size++;
}

---

顺序表-指定位置删除

原理都很简单：
从 （指定位置后一个元素）pos+1 处开始把值往前覆盖
pos 后面的元素以此类推；
最后ps->size–;

//函数申明
void SeqListErase(SL* ps, int pos);//指定位置删除

//函数实现
void SeqListErase(SL* ps, int pos)//指定位置删除
{
        assert(pos < ps->size);//断言
        int start = pos + 1;
        while (start < ps->size)
        {
               ps->a[start-1] = ps->a[start];
               ++start;
        }
        ps->size--;
}

---

顺序表-查找

//函数申明
void SeqListFind(SL* ps, SQDataType x);

//函数实现
void SeqListFind(SL* ps, SQDataType x)
{
        for (int i = 0; i < ps->size; i++)
        {
               if (ps->a[i] == x)
               {
                       return i;
               }
        }
        return -1;
}

找到返回位置i；
没找到就返回-1；

---

顺序表-修改

//函数申明
void SeqListModity(SL* ps,int pos, SQDataType x);


//函数实现
void SeqListModity(SL* ps, int pos, SQDataType x)
{
        assert(pos < ps->size);//断言
        ps -> a[pos] = x;//将修改的值赋给要修改的位置
}

文章分享的内容就到这里，
图片的演示过程就不展示了！可自行画图理解哦 ^ _^
再见！