顺序表大数据，请把它推把还不会顺序表的人

 前言： 刷题和面试兼顾还得看你啊-牛客网

近几年互联网受疫情影响，许多互联网都使用牛客网在线笔试招人

很多同学因为不熟悉牛客网的环境和使用，最后在线笔试面试中屡屡受挫

牛客网提供了语言巩固，算法提高等在线OJ题，更有面试真题，大厂内推！

链接附上点击链接注册牛客网

牛客网这么好用，但是下面几个关于牛客网的知识你了解过吗？

• 你知道你OJ过不了，牛客网几种经典的英文报错提示的含义吗？
• 你知道牛客网的OJ分为IO型和接口型吗？
• 你使用过牛客网的调试功能吗？

---

 

                                       每一个不曾起舞的日子,都是对生命的辜负! 

                                                                                                   --------尼采

目录

前言

动态顺序表的动态分配结构体的定义:

二、基本操作

备注:顺序表本质上就是动态开辟的数组,名字高大上,其实  very  easy!

---

---

一.基本介绍

1-1线性表

线性表 （linklist list） 是 数据结构 的一种，一个线性表是n个具有相同特性的数据元素的有限序列

顾名思义：线性表就像一条线,不会分叉(学到树和图你自然就明白了)

线性表分为:顺序表,链表,栈和队列

线性表的两种存储方式：顺序储存和链式存储

1-2顺序表(sequence list-----通常缩写为SeqList)

顺序表分类:静态顺序表和动态顺序表

(1)静态顺序表缺点:初始时开辟定长数组,在进行插入操作时容易超出预分配的空间长度,造成溢出等

(2)动态顺序表优点:初始时动态分配内存,在进行插入操作时可灵活扩充存储空间等,推荐使用

0.动态顺序表的动态分配结构体的定义:

1.  
   typedef int SeqDateType;
2.  
   typedef struct SeqList
3.  
   {
4.  
   SeqDataType* a;
5.  
   int size; // 有效数据的个数
6.  
   int capacity; // 容量
7.  
   }SeqList;

---

二、基本操作

---

1.顺序表的初始化

你要打开冰箱拿雪糕的前提就是你得先拥有一个冰箱（顺序表）,所以操作顺序表前我们得先创建一个顺序表啊

1.  
   void SeqListInit(SeqList* pq)
2.  
   {
3.  
    
4.  
   assert(pq);//等价于assert(pq != NULL)
5.  
    
6.  
   pq->a = NULL;
7.  
    
8.  
   pq->size = pq->capacity = 0;
9.  
   }

---

2.顺序表的销毁

顺序表的数组是动态开辟的,占用的是堆上的空间,需要程序员手动去释放,防止长时间占用内存,这既符合谁开辟谁释放的原则,更是一个毋庸置疑的好习惯!

1.  
   void SeqListDestory(SeqList* pq)
2.  
   {
3.  
   assert(pq);
4.  
    
5.  
   free(pq->a);
6.  
    
7.  
   pq->a = NULL;
8.  
    
9.  
   pq->capacity = pq->size = 0;
10.  
    }

备注:销毁同样改变了主函数内实参那个顺序表,所以依旧是传址调用

---

3.顺序表的打印

打印就是将顺序表展示在输出窗口的,但是这一步和打印数组一毛一样!

1.  
   void SeqListPrint(SeqList* pq)
2.  
   {
3.  
   assert(pq);
4.  
   for (int i = 0; i < pq->size; i)
5.  
   {
6.  
   printf("%d ", pq->a[i]);
7.  
   }
8.  
    
9.  
   printf("\n");
10.  
    }

---

4.顺序表插入时检查是否需要扩容

顺序表插入时检查是否需要扩容在每次插入操作时都会用到，所以建议封装成函数，模块化代码，需要时直接调用

1.  
   void SeqCheckCapacity(SeqList* pq)
2.  
   {
3.  
    
4.  
   if (pq->size == pq->capacity)
5.  
   {
6.  
   int newcapacity = pq->capacity == 0 ? 4 : pq->capacity * 2;
7.  
   SeqDataType* newA = realloc(pq->a, sizeof(SeqDataType)*newcapacity);
8.  
   if (newA == NULL)
9.  
   {
10.  
    printf("realloc fail\n");
11.  
    exit(-1);
12.  
    }
13.  
     
14.  
    pq->a = newA;
15.  
    pq->capacity = newcapacity;
16.  
    }
17.  
    }

---

 5.顺序表的尾插

顺序表中对于初学者最为头疼的是特殊情况的考虑和元素的后移前移操作，但是只要动动脑筋，就能运用自如，切忌死记硬背！

插入删除移动问题的见解:

1.

2.

对于插入数据，我们应该从数组尾处开始后移；对于删除数据，我们应该从删除端开始前移

（原因是从另一头移动会造成数据的覆盖）

类比:尾插就是食堂打饭时老老实实在最后一个人的位置后面排着队,并且干饭人的队伍又多了一名成员罢了.

1.  
   void SeqListPushBack(SeqList* pq, SeqDataType x)
2.  
   {
3.  
   assert(pq);
4.  
    
5.  
   SeqCheckCapacity(pq);
6.  
    
7.  
   pq->a[pq->size] = x;
8.  
   pq->size ;
9.  
   }

---

 6.顺序表的头插

类比:在食堂打饭的时候,你直接插队插到第一个位置去了,就是头插,那么你占了第一个位置,原来的人就必须得全部后移一个位置啦(哈哈)🤣

1.  
   void SeqListPushFront(SeqList* pq, SeqDataType x)
2.  
   {
3.  
   assert(pq);
4.  
    
5.  
   SeqCheckCapacity(pq);
6.  
    
7.  
   int end = pq->size - 1;
8.  
   while (end >= 0)
9.  
   {
10.  
    pq->a[end 1] = pq->a[end];
11.  
    --end;
12.  
    }
13.  
     
14.  
    pq->a[0] = x;
15.  
    pq->size ;
16.  
    }

---

7.顺序表的尾删

类比:排队打饭时你突然发现阿姨颠勺颠的厉害,不想在这个窗口排队了

1.  
   void SeqListPopBack(SeqList* pq)
2.  
   {
3.  
   assert(pq);
4.  
   assert(pq->size > 0);
5.  
    
6.  
   --pq->size;
7.  
   }

8.顺序表的头删

类比:你不文明的头插行为被阿姨发现了,在谩骂声下,你不得不离开队伍第一的位置,其他人又可以前进一个位置了

1.  
   void SeqListPopFront(SeqList* pq)
2.  
   {
3.  
   assert(pq);
4.  
   assert(pq->size > 0);
5.  
    
6.  
   int begin = 0;
7.  
   while (begin < pq->size-1)
8.  
   {
9.  
   pq->a[begin] = pq->a[begin 1];
10.  
    begin;
11.  
    }
12.  
     
13.  
    pq->size--;
14.  
     
15.  
    }

---

9.顺序表的按值查找

类比:你想找队伍里的小明同学,于是你从队头走到队尾,挨个匹配每个人是否是小明,找到就不找了.

1.  
   int SeqListFind(SeqList* pq, SeqDataType x)
2.  
   {
3.  
   assert(pq);
4.  
    
5.  
   for (int i = 0; i < pq->size; i)
6.  
   {
7.  
   if (pq->a[i] == x)
8.  
   {
9.  
   return i;
10.  
    }
11.  
    }
12.  
     
13.  
    return -1;
14.  
    }

10.顺序表的任意位置插入

类比:又是插队!不过这次你是在下标为pos的位置的前一位插入,这就要从插入的位置到最后一位均后退一位才能行（在数组下标为pos的位置前插入一个e元素）

1.  
   void SeqListInsert(SeqList* pq, int pos, SeqDataType x)
2.  
   {
3.  
   assert(pq);
4.  
   assert(pos >= 0 && pos <= pq->size);
5.  
    
6.  
   SeqCheckCapacity(pq);
7.  
    
8.  
   int end = pq->size - 1;
9.  
   while (end >= pos)
10.  
    {
11.  
    pq->a[end 1] = pq->a[end];
12.  
    --end;
13.  
    }
14.  
     
15.  
    pq->a[pos] = x;
16.  
    pq->size ;
17.  
    }

11.顺序表的任意位置删除

类比:不文明的行为当然不能容忍,这次你又被踢出去了（删除数组下标为pos的元素）

1.  
   void SeqListErase(SeqList* pq, int pos)
2.  
   {
3.  
   assert(pq);
4.  
   assert(pos >= 0 && pos < pq->size);
5.  
    
6.  
   int begin = pos;
7.  
   while (begin <= pq->size-1)
8.  
   {
9.  
   pq->a[begin] = pq->a[begin 1];
10.  
    begin;
11.  
    }
12.  
     
13.  
    pq->size--;
14.  
    }

 上面有很多步骤都是可以复用的，例如头插就是在第一个元素前插入一个元素，尾插就是在最后一个元素后插入一个元素等等，快去找找看看吧！

下面来实战一下吧：

1.  
    
2.  
   #include<stdio.h>
3.  
   #include<stdlib.h>
4.  
   #include<assert.h>
5.  
    
6.  
   typedef int ElemType;
7.  
    
8.  
   typedef struct SeqList
9.  
   {
10.  
    ElemType* a;
11.  
    int size;
12.  
    int capacity;
13.  
    }SeqList;
14.  
     
15.  
     
16.  
     
17.  
    void InitSeqList(SeqList* ps)
18.  
    {
19.  
    ps->a = (ElemType*)malloc(sizeof(ElemType) * 4);
20.  
    if (ps->a == NULL)
21.  
    {
22.  
    printf("malloc fail\n");
23.  
    exit(-1);
24.  
    }
25.  
    ps->size = 0;
26.  
    ps->capacity = 4;
27.  
    }
28.  
     
29.  
    void CheckCapacity(SeqList* ps)
30.  
    {
31.  
    if (ps->size == ps->capacity)
32.  
    {
33.  
    int newcapacity = 2 * ps->capacity;
34.  
    ElemType* temp = realloc(ps->a, sizeof(ElemType) * newcapacity);
35.  
    if (temp == NULL)
36.  
    {
37.  
    printf("realloc fail\n");
38.  
    exit(-1);
39.  
    }
40.  
    else
41.  
    {
42.  
    ps->capacity = newcapacity;
43.  
    ps->a = temp;
44.  
    }
45.  
    }
46.  
     
47.  
    }
48.  
     
49.  
    void SeqListPushBack(SeqList* ps, ElemType e)
50.  
    {
51.  
    CheckCapacity(ps);
52.  
     
53.  
    ps->a[ps->size] = e;
54.  
    ps->size ;
55.  
    }
56.  
     
57.  
    void PrintSeqList(SeqList* ps)
58.  
    {
59.  
    printf("顺序表的打印： ");
60.  
    for (int i = 0; i < ps->size; i )
61.  
    {
62.  
    printf("%d\t", ps->a[i]);
63.  
    }
64.  
    }
65.  
     
66.  
    void SeqListInsert(SeqList* ps, int j, ElemType e)
67.  
    {
68.  
    assert(j >= 0 && j <= ps->size);
69.  
    CheckCapacity(&ps);
70.  
    for (int i = ps->size - 1; i >= j - 1; i--)
71.  
    {
72.  
    ps->a[i 1] = ps->a[i];
73.  
    }
74.  
    ps->a[j - 1] = e;
75.  
    ps->size ;
76.  
    }
77.  
     
78.  
    void SeqListDelete(SeqList* ps, int j)
79.  
    {
80.  
    for (int i = j; i <= ps->size - 1; i )
81.  
    {
82.  
    ps->a[i - 1] = ps->a[i];
83.  
    }
84.  
    ps->size--;
85.  
    }
86.  
     
87.  
    int FindSeqList(SeqList* ps, ElemType e)
88.  
    {
89.  
    for (int i = 0; i < ps->size; i )
90.  
    {
91.  
    if (e == ps->a[i])
92.  
    {
93.  
    return i 1;
94.  
    }
95.  
    }
96.  
    return 0;
97.  
    }
98.  
     
99.  
    ElemType GetSeqList(SeqList* ps, int j)
100.  
     {
101.  
     assert(j >= 1 && j <= ps->size);
102.  
     return ps->a[j - 1];
103.  
     }
104.  
      
105.  
     void SeqListClear(SeqList* ps)
106.  
     {
107.  
     ps->a = NULL;
108.  
     ps->size = ps->capacity = 0;
109.  
     }
110.  
      
111.  
     void SeqListDestory(SeqList* ps)
112.  
     {
113.  
     free(ps->a);
114.  
     ps->a = NULL;
115.  
     ps->size = ps->capacity = 0;
116.  
     }
117.  
      
118.  
     int main()
119.  
     {
120.  
     printf("宋永红的线性表（1）作业：\n");
121.  
     SeqList pq;
122.  
     //顺序表的初始化
123.  
     InitSeqList(&pq);
124.  
      
125.  
     //在顺序表的尾上插入数据
126.  
     SeqListPushBack(&pq, 1);
127.  
     SeqListPushBack(&pq, 2);
128.  
     SeqListPushBack(&pq, 3);
129.  
     SeqListPushBack(&pq, 4);
130.  
      
131.  
     //打印顺序表
132.  
     PrintSeqList(&pq);
133.  
     printf("\n");
134.  
      
135.  
     //删除第N个元素
136.  
     int n = 3;
137.  
     SeqListDelete(&pq, n);
138.  
     printf("删除第%d个数据后",n);
139.  
     PrintSeqList(&pq);
140.  
     printf("\n");
141.  
      
142.  
     //在第n个位置前插入一个元素
143.  
     SeqListInsert(&pq, 2, 100);
144.  
     printf("在第2个位置插入100这个数据后");
145.  
     PrintSeqList(&pq);
146.  
     printf("\n");
147.  
      
148.  
     //查找第n个元素，存在返回其位序，找不到返回0
149.  
     int findNums = 100;
150.  
     int ret=FindSeqList(&pq, findNums);
151.  
     if (ret == 0)
152.  
     {
153.  
     printf("要找的%d不存在\n", findNums);
154.  
     }
155.  
     else
156.  
     {
157.  
     printf("%d存在，位序是%d\n", findNums, ret);
158.  
     }
159.  
      
160.  
     //获取第n个元素
161.  
     ElemType x = GetSeqList(&pq, 2);
162.  
     printf("顺序表第2个位置的元素是%d\n", x);
163.  
     printf("\n");
164.  
      
165.  
     //清空
166.  
     SeqListClear(&pq);
167.  
      
168.  
     //销毁
169.  
     SeqListDestory(&pq);
170.  
      
171.  
     }

打印结果：

为什么有扩容没有缩容？

realloc可以达到缩容的目的，但是是开辟了一块新空间来存放旧空间里的内容，这个步骤是需要消耗时间的，所以缩容的话就相当于是用时间换空间，如果不缩容，就相当于是用空间换时间，第一局：平局

但是第二局：不缩容还有一个好处就是在后面又想插入数据的时候，可以不用再扩容，减少扩容消耗的时间，同时内存对于空间还是比较慷慨的。

所以综合来看没有缩容，但是扩容肯定是必须的

这篇好文章是转载于：学新通技术网