0
0

数据结构——线性表之顺序表篇

前言

在介绍顺序表之前我们先简单了解一下线性表：

线性表是n个具有相同特性的数据元素的有限序列，在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

常见的线性表：顺序表、链表、栈、队列、字符串...

顺序表的介绍和简单实现

关于顺序表

顺序表就是采用数组存储，但在数组的基础上，要从头部开始存储且是连续存储，中间不能跳跃

顺序表的分类

顺序表也分为动态线性表和静态线性表。

静态线性表：使用定长的数组存储，给定的空间是固定的，也可以理解为你申请了一个房间的空间，你只能在这个房间使用空间。由于不灵活这里就直接介绍动态的

动态线性表：采用动态开辟的数组存储，可以灵活的使用空间，空间不够可以realloc扩容。可以理解为你开始申请了一个房间，而当你整个房间的空间用完后，你可以再申请一个房间的空间使用。

如果有不了解动态内存分配的可以小伙伴，可以看看我之前写的动态内存分配

顺序表的初步组成

由于是动态内存分配，我们需要定义一个结构体：

1.存放一个指针用来维护动态内存开辟的空间

2.存放变量size，记录存放的个数

3.存放变量capacity，记录当前空间的容量，空间满了就扩容

  1. typedef int DataType;
  2. typedef struct SeqList
  3. {
  4.     DataType* p;
  5.     int sz;
  6.     int capacity;
  7. }SL;

功能函数的声明

SeqList.h

  1. #pragma once
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6. #include <assert.h>
  8. typedef int DataType;
  9. typedef struct SeqList
  10. {
  11.     DataType* p;
  12.     int sz;
  13.     int capacity;
  14. }SL;
  15. //顺序表初始化
  16. void SeqListInit(SL* pc);
  17. //检查顺序表的容量
  18. void SeqListCheckCapacity(SL* pc);
  19. //顺序表尾插
  20. void SeqListpushback(SL* pc, DataType x);
  21. //顺序表尾删
  22. void SeqListpopback(SL* pc);
  23. //顺序表头插
  24. void SeqListpushfront(SL* pc, DataType x);
  25. //顺序表头删
  26. void SeqListpopfront(SL* pc);
  27. //打印顺序表
  28. void SeqListPrint(SL* pc);
  29. //删除顺序表
  30. void SeqListDestory(SL* pc);
  31. //顺序表指定pos位置插入
  32. void SeqListInsert(SL* pc, DataType x, int pos);
  33. // 删除pos位置的数据
  34. void SeqListErase(SL* pc, int pos);
  35. // 找到了返回x位置下标，没有找到返回-1
  36. int SeqListFind(SL* pc, DataType x);

功能函数的实现

初始化

我们先创建一个结构体变量 SL s，然后传变量s的地址通过一系列的接口函数实现顺序表的增删查改。首先要先初始化s，将p置空，sz和capacity置0。

SL s;
SeqListInit(&s);

  1. void SeqListInit(SL* pc)
  2. {
  3.     pc->sz = pc->capacity = 0;
  4.     pc->p = NULL;
  5. }

检查容量判断是否需要扩容

定义一个check函数判断空间是否满了，如果满了就扩容，每次扩2倍，比如100空间的容量要变成200空间的容量，所以当插入数据时，首先需要调用check函数判断容量是否满了

  1. void SeqListCheckCapacity(SL* pc)
  2. {    
  3.     //没有空间则扩容
  4.     if (pc->sz == pc->capacity)
  5.     {
  6.         int newcapacity = pc->capacity == 0 ? 4 : pc->capacity * 2;
  7.         DataType* tmp = (DataType*)realloc(pc->p, newcapacity * sizeof(DataType));
  8.         if (tmp == NULL)
  9.         {
  10.             printf("%s\n", strerror(errno));
  11.             exit(-1);
  12.         }
  13.         pc->p = tmp;
  14.         pc->capacity = newcapacity;
  15.     }
  16. }

然后就是顺序表的头插pushfront，头删popfront，尾插pushback，尾删popback，指定pos位置插入pushpop，destory销毁等，顺序表的源码

尾插，尾删直接插入删除，头插，头删需要挪动数据后插入删除

头插

假定当前的容量capacity是8，sz已经存放的个数是4，而我们要头插数据5的话，就要把顺序表整体后移，然后插入5，此时数据增加了一个，sz就要++，

对指针p，p[tmp]等价于 *(p+tmp)

  1. void SeqListpushfront(SL* pc, DataType x)
  2. {
  3.     SeqListCheckCapacity(pc);
  4.     int tmp = pc->sz;
  5.     while (tmp > 0)
  6.     {
  7.         pc->p[tmp] = pc->p[tmp - 1];
  8.         --tmp;
  9.     }
  10.     pc->p[0] = x;
  11.     pc->sz++;
  12. }

头删

头删与头插类似，不过是向左挪动数据删除顺序表中的第一个数据，但是当顺序表没有数据时就不能头删了，所以我们要assert断言一下，断言为真程序就继续，为假就会报错了，涉及指针大部分需要断言

  1. void SeqListpopfront(SL* pc)
  2. {    
  3.     assert(pc->sz > 0);
  4.     int tmp = 1;
  5.     while (tmp < pc->sz)
  6.     {
  7.         pc->p[tmp - 1] = pc->p[tmp];
  8.         ++tmp;
  9.     }
  10.     pc->sz--;
  11. }

尾插

尾插只需要在当前顺序表的最后一个数据后面插入，当然插入数据时首先要check容量

  1. void SeqListpushback(SL* pc, DataType x)
  2. {    
  3.     SeqListCheckCapacity(pc);
  4.     pc->p[pc->sz] = x;
  5.     pc->sz++;
  6. }

尾删

先断言顺序表是否有数据支持删除

  1. void SeqListpopback(SL* pc)
  2. {
  3.     assert(pc->sz > 0);
  4.     pc->sz--;
  5. }

指定数据位置插入

和头插类似找到数据后挪动后面的数据再插入即可，这里的pos表示顺序表中的第几个数

  1. void SeqListInsert(SL* pc, DataType x, int pos)
  2. {
  3.     SeqListCheckCapacity(pc);
  4.     assert(pos <= (pc->sz+1) && pos > -1);    //pos表示第几个数，不是下标索引
  5.     int tmp = pc->sz;
  6.     while (pos <= tmp + 1)
  7.     {
  8.         pc->p[tmp] = pc->p[tmp - 1];
  9.         tmp--;
  10.     }
  11.         pc->p[pos - 1] = x;
  12.     pc-> sz++;
  13. }

指定数据删除

那我们只需找到这个数，然后通过左移删除即可

  1. void SeqListErase(SL* pc, int pos)
  2. {
  3.     assert(pos <= pc->sz && pos > -1);
  4.     while (pos <= pc->sz)
  5.     {
  6.         pc->p[pos - 1] = pc->p[pos];
  7.         pos++;
  8.     }
  9.     pc->sz--;
  10. }

寻找数据并返回下标

遍历顺序表找到后返回下标，找不到就返回-1（那么前提是顺序表中的数都是无符号类型）

  1. int SeqListFind(SL* pc, DataType x)
  2. {
  3.     for (int i = 0; i < pc->sz; i++)
  4.     {
  5.         if (pc->p[i] == x)
  6.             return i;
  7.     }
  8.     return -1;
  9. }

销毁顺序表

因为我们是在堆区动态开辟的空间，不用了就要free释放空间避免内存泄漏

  1. void SeqListDestory(SL* pc)
  2. {
  3.     pc->sz = 0;
  4.     pc->capacity = 0;
  5.     free(pc->p);
  6.     pc->p = NULL;
  7. }

源码

SeqList.c函数定义

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2. #include "SeqList.h"
  4. void SeqListInit(SL* pc)
  5. {
  6.     pc->sz = pc->capacity = 0;
  7.     pc->p = NULL;
  8. }
  9. void SeqListCheckCapacity(SL* pc)
  10. {    
  11.     //没有空间则扩容
  12.     if (pc->sz == pc->capacity)
  13.     {
  14.         int newcapacity = pc->capacity == 0 ? 4 : pc->capacity * 2;
  15.         DataType* tmp = (DataType*)realloc(pc->p, newcapacity * sizeof(DataType));
  16.         if (tmp == NULL)
  17.         {
  18.             printf("%s\n", strerror(errno));//errno是错误码,strerror()根据错误码判断出错原因
  19.             exit(-1);//扩容失败后就直接退出程序了
  20.         }
  21.         pc->p = tmp;
  22.         pc->capacity = newcapacity;
  23.     }
  24. }
  25. void SeqListPrint(SL* pc)
  26. {
  27.     for (int i = 0; i < pc->sz; i++)
  28.     {
  29.         printf("%d\t", pc->p[i]);
  30.     }
  31.     printf("\n");
  32. }
  33. void SeqListpushback(SL* pc, DataType x)
  34. {    
  35.     SeqListCheckCapacity(pc);
  36.     pc->p[pc->sz] = x;
  37.     pc->sz++;
  38. }
  39. void SeqListpopback(SL* pc)
  40. {
  41.     assert(pc->sz > 0);
  42.     pc->sz--;
  43. }
  44. void SeqListpushfront(SL* pc, DataType x)
  45. {
  46.     SeqListCheckCapacity(pc);
  47.     int tmp = pc->sz;
  48.     while (tmp > 0)
  49.     {
  50.         pc->p[tmp] = pc->p[tmp - 1];
  51.         --tmp;
  52.     }
  53.     pc->p[0] = x;
  54.     pc->sz++;
  55. }
  57. void SeqListpopfront(SL* pc)
  58. {    
  59.     assert(pc->sz > 0);
  60.     int tmp = 1;
  61.     while (tmp < pc->sz)
  62.     {
  63.         pc->p[tmp - 1] = pc->p[tmp];
  64.         ++tmp;
  65.     }
  66.     pc->sz--;
  67. }
  69. void SeqListDestory(SL* pc)
  70. {
  71.     pc->sz = 0;
  72.     pc->capacity = 0;
  73.     free(pc->p);
  74.     pc->p = NULL;
  75. }
  76. void SeqListInsert(SL* pc, DataType x, int pos)
  77. {
  78.     SeqListCheckCapacity(pc);
  79.     assert(pos <= (pc->sz+1) && pos > -1);    //pos表示第几个数，不是下标索引
  80.     int tmp = pc->sz;
  81.     while (pos <= tmp + 1)
  82.     {
  83.         pc->p[tmp] = pc->p[tmp - 1];
  84.         tmp--;
  85.     }
  86.         pc->p[pos - 1] = x;
  87.     pc-> sz++;
  88. }
  90. void SeqListErase(SL* pc, int pos)
  91. {
  92.     assert(pos <= pc->sz && pos > -1);
  93.     while (pos <= pc->sz)
  94.     {
  95.         pc->p[pos - 1] = pc->p[pos];
  96.         pos++;
  97.     }
  98.     pc->sz--;
  99. }
  101. int SeqListFind(SL* pc, DataType x)
  102. {
  103.     for (int i = 0; i < pc->sz; i++)
  104.     {
  105.         if (pc->p[i] == x)
  106.             return i;
  107.     }
  108.     return -1;
  109. }

测试代码

建议大家每写完几个函数就可以先通过接口测试一下函数的功能是否满足自己的要求

开头的定义结构体变量s，和初始化都是必不可少的

  1. #include "SeqList.h"
  3. void Test2()
  4. {
  5.     SL s;
  6.     SeqListInit(&s);
  7.     SeqListpushback(&s, 1);
  8.     SeqListpushback(&s, 2);
  9.     SeqListpushback(&s, 3);
  10.     SeqListpushback(&s, 4);
  11.     SeqListpushback(&s, 5);
  12.     SeqListPrint(&s);
  13.     SeqListInsert(&s, 10, 6);
  14.     SeqListPrint(&s);
  15.     SeqListErase(&s, 1);
  16.     SeqListPrint(&s);
  17.     printf("%d\n", SeqListFind(&s, 10));
  18.     printf("%d\n", SeqListFind(&s, 20));
  19.     SeqListDestory(&s);
  20. }
  21. int main()
  22. {    
  23.     //Test1();
  24.     Test2();
  25. }

顺序表小结

顺序表也是有缺陷的：

1️⃣空间不够时需要扩容的，而扩容是需要付出代价的，我们一般是扩2倍，这也从一定程度上导致空间浪费，（比如我只需要120的空间，而100的空间满了，扩容为200，导致80的空间浪费）且原空间不够扩容的话，需要将数据全部迁移，大大降低了效率。

2️⃣顺序表是从头开始且连续存储数据的，而当我们要在头部或是中间位置插入删除数据时，需要挪动数据，也大大降低了效率。

当然顺序表也不是一无是处的，顺序表空间是连续有序的，支持随即访问，有很多程序都要支持随机访问

针对顺序表的这两个缺陷又引入了链表，之后会给大家介绍链表以及链表的实现。

不是看到希望才去坚持，而是坚持了才看到希望，敬每一位努力奋斗的你和学习编程的你。希望我的文章能对你有所帮助。欢迎👍点赞 ，📝评论，🌟关注，⭐️收藏

标签： 数据结构 链表 算法
本文转载自: https://blog.csdn.net/weixin_46016019/article/details/122311354
版权归原作者 想学好编程的小菜鸟 所有， 如有侵权，请联系我们删除。
登录后发布评论

“数据结构&mdash;&mdash;线性表之顺序表篇”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？