一、线性表

是什么线性表

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

线性表的结构

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

---

二、顺序表

1、什么是顺序表

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

简单来说，顺序表就是数组，只是要求数组里面的元素必须连续存储而已。

2、顺序表的分类

顺序一般分为两类：静态顺序表和动态顺序表。

静态顺序表：采用定长数组来存储元素。

#define MAX 1000  //数组的最大长度
typedef int SLDtataType;  //重命名数据类型
typedef struct SeqList
{SLDtataType data[MAX];  //使用定长数组来存储数据size_t size;  //有效数据的个数
}SL;

动态顺序表：使用动态开辟的数据来存储元素。

typedef int SLDataType;  //将数据类型重命名为SLDataType
typedef struct SeqList
{SLDataType* data;     //对应数据类型的指针，用来指向动态开辟的空间size_t size;          //记录当前有效数据的个数size_t capacity;      //记录当前容量，不够就增容
}SL;

两种顺序表的对比：相较于动态顺序表，静态顺序表存在很大的缺陷，那就是空间问题：当我们数据量很大时给定的空间可能不够用，但我们数据量比较小时，给定的空间又可能过大，造成空间浪费，即静态顺序表只适用于确定知道需要存多少数据的场景；所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，而静态顺序表很少使用。下面我们用C语言来模拟实现一个动态的顺序表。

---

三、动态顺序表的实现

1、结构的定义

#define DEF_SIZE 5       //初始容量
#define CRE_SIZE 2       //一次扩容的倍数
typedef int SLDataType;  //将数据类型重命名为SLDataTypetypedef struct SeqList
{SLDataType* data;  //对应数据类型的指针，用来指向动态开辟的空间size_t size;          //记录当前有效数据的个数size_t capacity;      //记录当前容量，不够就增容
}SL;

如上：我们将要管理的数据类型重命名为SLDateType，这样以后当我们要用此顺序表管理其他数据类型时，我们就只需要改动这一个地方。

其次，相较于静态顺序表，我们的结构体多了一个参数 – capacity，我们用它来记录顺序表当前的容量，当当前的有效数据个数size与它相等时，我们就进行扩容；由于数据个数和顺序表的容量都不可能小于0，所以我们将其定义为size_t的。

最后就是关于初始容量和每次扩增倍数的问题，这里把初始容量设定为5，然后把扩增倍数设定为2，即我们的顺序表每次扩容两倍。

2、顺序表的初始化

在初始化函数中，我们把size和capacity都置为相应大小，并且为data指针动态开辟一块空间，用于存储数据。

//初始化顺序表
void SeqListInit(SL* psl)
{assert(psl);  //断言：防止psl为空psl->data = (SLDataType*)calloc(DEF_SIZE, sizeof(SLDataType));  //开辟默认大小的空间并初始化if (psl == NULL)  //判空{perror("calloc fail");  //打印错误信息return;}psl->size = 0;psl->capacity = DEF_SIZE;
}

3、检查容量

在检查容量的函数中，当我们结构体中的size和capacity相等时，我们就扩容，在扩容时我们要注意不要直接用data指针来接收realloc函数的返回值，避免扩容失败导致data指针找不到之前管理的空间，从而造成内存泄漏。

//检查容量（增容）
void CheckCapacity(SL* psl)
{assert(psl);  //断言：防止psl为空if (psl->size == psl->capacity)  //当数据个数和容量相等时扩容{//将realloc的返回值交由一个临时变量保存，防止扩容失败丢失原来空间的地址SLDataType* ptr = (SLDataType*)realloc(psl->data, psl->capacity * CRE_SIZE * sizeof(SLDataType));if (ptr == NULL)  //判空{perror("realloc fail");return;}psl->data = ptr;psl->capacity *= CRE_SIZE;  //增加容量}
}

4、在头部插入数据

在头部插入数据时，我们需要先将顺序表中的数据整体向后挪动一位，然后在顺序表的开头插入；在插入完成后记得要让size++。

//在头部插入数据
void SeqListPushFront(SL* psl, SLDataType x)
{assert(psl);  //判空CheckCapacity(psl);  //检查容量int i = 0;for (i = psl->size - 1; i >= 0; i--){psl->data[i + 1] = psl->data[i];  //将数据整体向后移}psl->data[0] = x;  //插入数据psl->size++;
}

5、在尾部插入数据

在尾部插入数据很简单，直接插入就行。

//在尾部插入数据
void SeqListPushBack(SL* psl, SLDataType x)
{assert(psl);  //判空CheckCapacity(psl);  //检查容量psl->data[psl->size] = x;  //插入数据psl->size++;
}

6、在指定位置插入数据

在此函数中，我们需要先将pos及其之后的元素整体向后挪动一位，然后再在pos处插入数据。

//在任意位置插入数据
void SeqListInsert(SL* psl, size_t pos, SLDataType x)
{assert(psl);assert(pos <= psl->size);  //断言 因为可能会在尾部插入数据，所以pos可以等于sizeCheckCapacity(psl);  //检查容量size_t end = psl->size;while (end > pos)  //把pos及以后的数据向后挪动一位{psl->data[end] = psl->data[end - 1];--end;}psl->data[pos] = x;  //插入数据++psl->size;
}

由于尾插和头插也可以通过调用 SeqListInsret 函数实现，所以我们可以对头插和尾插函数进行改造，以此来简化代码：

在头部插入数据

//在头部插入数据
void SeqListPushFront(SL* psl, SLDataType x)
{assert(psl);SeqListInsert(psl, 0, x);  //相当于在0位置处插入数据
}

在尾部插入数据

//在尾部删除数据
void SeqListPopBack(SL* psl)
{assert(psl);SeqListErase(psl, psl->size - 1);  //相当于在size-1处插入数据（数组下标从0开始）
}

7、在尾部删除数据

删除尾部的数据很简单，我们只需要将size–即可，并不需要对其进行改动，因为我们下一次插入数据时会直接将原来空间中的数据覆盖掉。

//在尾部删除数据
void SeqListPopBack(SL* psl)
{assert(psl);assert(psl->size);psl->size--;  //如果尾部有数据，直接让size--即可
}

8、在头部删除数据

在头部删除数据，我们只需要将顺序表中的数据整体向前挪动一位，然后将size–即可。

//在头部删除数据
void SeqListPopFront(SL* psl)
{assert(psl);assert(psl->size);size_t i = 0;for (i = 0; i < psl->size - 1; i++){psl->data[i] = psl->data[i + 1];  //让表中的数据依次往前移}psl->size--;
}

9、删除指定位置的数据

删除指定位置数据，我们需要将pos后面的数据整体向前挪动一位，然后让size–。

//删除指定位置的数据
void SeqListErase(SL* psl, size_t pos)
{assert(psl);assert(pos < psl->size);size_t i = 0;for (i = pos; i < psl->size - 1; i++){psl->data[i] = psl->data[i + 1];}psl->size--;
}

和上面的插入数据一样，我们也可以通过调用 SeqListErase 函数来实现数据的头删和尾删。

在头部删除数据

//在头部删除数据
void SeqListPopFront(SL* psl)
{assert(psl);SeqListErase(psl, 0);  //相当于删除0下标处的数据
}

在尾部删除数据

//在尾部删除数据
void SeqListPopBack(SL* psl)
{assert(psl);SeqListErase(psl, psl->size - 1);  //相当于删除size-1下标处的数据
}

面试题：删除数据是否要缩容？

我们知道，插入数据空间不够时我们要增容，那么删除数据达到一定的数量后我们是否要缩容呢？答案是不用缩容。原因如下：

第一：我们缩容之后插入数据又需要重新增容，而增容是有代价的，会降低程序的效率。我们知道 realloc 函数扩容分为两种情况，一种是原地扩，即当原来的空间后面有足够的空闲空间时，操作系统会直接将那一块空间交由我们使用，这种情况对效率影响不大；另一种是异地扩，即当原来空间后面没有足够的的空间开辟时，操作系统会在另外空间足够的地方为我们开辟一块新的空间，这时操作系统需要先将我们原来空间中的数据拷贝到新空间中，再将原来的空间释放掉，这种情况对效率的影响就比较大了。

第二：缩容也是有代价的。其实缩容和扩容的过程是一样的，都分为原地和异地，会对程序效率造成影响。

第三：顺序表申请的是一块连续的空间，而free函数数并不能释放连续空间的一部分，只能全部一起释放，所以这里即使想释放也是做不到的。

所以综合前面三个因素考虑，顺序表删除数据不会缩容；这是我们典型的以空间换时间的做法。

10、查找数据

当我们找到该元素时，我们返回元素的下标；当该元素不存在时，我们返回一个无意义的值。（如-1）

//查找数据
int SeqListFind(const SL* psl, SLDataType x)
{assert(psl);int i = 0;for (i = 0; i < (int)psl->size; i++){if (psl->data[i] == x)return i;  //找到元素所在返回下标}return -1;  //找不到返回-1（一个无效下标）
}

11、修改指定位置的数据

//修改指定位置的数据
void SeqListModify(SL* psl, size_t pos, SLDataType x)
{assert(psl);assert(pos < psl->size);  //断言psl->data[pos] = x;  //修改数据
}

12、打印顺序表中的数据

//打印顺序表中的数据
void SeqListPrint(const SL* psl)
{assert(psl);  //判空size_t i = 0;for (i = 0; i < psl->size; i++){printf("%d ", psl->data[i]);}printf("\n");
}

13、顺序表的销毁

在销毁顺序表的时候我们一定要记得将前面动态开辟的空间释放掉，防止内存泄漏。

//销毁顺序表
void SeqListDestory(SL* psl)
{assert(psl);  //断言：防止psl为空free(psl->data);    //释放（避免内存泄漏）psl->data = NULL;   //置空（避免野指针）psl->size = 0;psl->capacity = 0;
}

---

四、完整代码

1、SeqLIst.h

#pragma once  //防止头文件重复包含//头文件的包含
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>//符号与结构的定义
#define DEF_SIZE 5       //初始容量
#define CRE_SIZE 2       //一次扩容的倍数
typedef int SLDataType;  //将数据类型重命名为SLDataTypetypedef struct SeqList
{SLDataType* data;  //对应数据类型的指针，用来指向动态开辟的空间size_t size;          //记录当前有效数据的个数size_t capacity;      //记录当前容量，不够就增容
}SL;//函数的声明
//初始化顺序表
void SeqListInit(SL* psl);
//在尾部插入数据
void SeqListPushBack(SL* psl, SLDataType x);
//在头部插入数据
void SeqListPushFront(SL* psl, SLDataType x);
//在尾部删除数据
void SeqListPopBack(SL* psl);
//在头部删除数据
void SeqListPopFront(SL* psl);
//在指定下标处插入数据
void SeqListInsert(SL* psl, size_t pos, SLDataType x);
//在指定下标处删除数据
void SeqListErase(SL* psl, size_t pos);
//查找数据
int SeqListFind(const SL* psl, SLDataType x);
//修改指定位置数据
void SeqListModify(SL* psl, size_t pos, SLDataType x);
//打印顺序表中的数据
void SeqListPrint(const SL* psl);
//检查容量(增容)
void CheckCapacity(SL* psl);
//销毁顺序表
void SeqListDestory(SL* psl);

2、SeqList.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"//初始化顺序表
void SeqListInit(SL* psl)
{assert(psl);  //断言：防止psl为空psl->data = (SLDataType*)calloc(DEF_SIZE, sizeof(SLDataType));  //开辟默认大小的空间并初始化if (psl == NULL)  //判空{perror("calloc fail");  //打印错误信息return;}psl->size = 0;psl->capacity = DEF_SIZE;
}//销毁顺序表
void SeqListDestory(SL* psl)
{assert(psl);  //断言：防止psl为空free(psl->data);    //释放（避免内存泄漏）psl->data = NULL;   //置空（避免野指针）psl->size = 0;psl->capacity = 0;
}//检查容量（增容）
void CheckCapacity(SL* psl)
{assert(psl);  //断言：防止psl为空if (psl->size == psl->capacity)  //当数据个数和容量相等时扩容{//将realloc的返回值交由一个临时变量保存，防止扩容失败丢失原来空间的地址SLDataType* ptr = (SLDataType*)realloc(psl->data, psl->capacity * CRE_SIZE * sizeof(SLDataType));if (ptr == NULL)  //判空{perror("realloc fail");return;}psl->data = ptr;psl->capacity *= CRE_SIZE;  //增加容量}
}//在尾部插入数据
void SeqListPushBack(SL* psl, SLDataType x)
{assert(psl);SeqListInsert(psl, psl->size, x);  //直接调用insert函数//assert(psl);  //判空//CheckCapacity(psl);  //检查容量//psl->data[psl->size] = x;  //插入数据//psl->size++;
}//在头部插入数据
void SeqListPushFront(SL* psl, SLDataType x)
{assert(psl);SeqListInsert(psl, 0, x);  //直接调用insert函数//assert(psl);  //判空//CheckCapacity(psl);  //检查容量//int i = 0;//for (i = psl->size - 1; i >= 0; i--)//{// psl->data[i + 1] = psl->data[i];  //将数据整体向后移//}//psl->data[0] = x;  //插入数据//psl->size++;
}//打印顺序表中的数据
void SeqListPrint(const SL* psl)
{assert(psl);  //判空size_t i = 0;for (i = 0; i < psl->size; i++){printf("%d ", psl->data[i]);}printf("\n");
}//在尾部删除数据
void SeqListPopBack(SL* psl)
{assert(psl);SeqListErase(psl, psl->size - 1);  //直接调用Erase函数//assert(psl);//assert(psl->size);//psl->size--;  //如果尾部有数据，直接让size--即可
}//在头部删除数据
void SeqListPopFront(SL* psl)
{assert(psl);SeqListErase(psl, 0);  //直接调用Erase函数//assert(psl);//assert(psl->size);//size_t i = 0;//for (i = 0; i < psl->size - 1; i++)//{//   psl->data[i] = psl->data[i + 1];  //让表中的数据依次往前移//}//psl->size--;
}//查找数据
int SeqListFind(const SL* psl, SLDataType x)
{assert(psl);int i = 0;for (i = 0; i < (int)psl->size; i++){if (psl->data[i] == x)return i;  //找到元素所在返回下标}return -1;  //找不到返回-1（一个无效下标）
}//修改指定位置的数据
void SeqListModify(SL* psl, size_t pos, SLDataType x)
{assert(psl);assert(pos < psl->size);  //断言psl->data[pos] = x;  //修改数据
}//在指定下标处插入数据
void SeqListInsert(SL* psl, size_t pos, SLDataType x)
{assert(psl);assert(pos <= psl->size);  //断言  因为可能会在尾部插入数据，所以pos可以等于sizeCheckCapacity(psl);  //检查容量size_t end = psl->size;while (end > pos)  //把pos及以后的数据向后挪动一位{psl->data[end] = psl->data[end - 1];--end;}psl->data[pos] = x;  //插入数据++psl->size;
}//在指定下标处删除数据
void SeqListErase(SL* psl, size_t pos)
{assert(psl);assert(pos < psl->size);size_t i = 0;for (i = pos; i < psl->size - 1; i++){psl->data[i] = psl->data[i + 1];}psl->size--;
}

3、test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include "SeqList.h"void test1()  //测试插入
{//初始化SL sl;SeqListInit(&sl);//尾插SeqListPushBack(&sl, 1);SeqListPushBack(&sl, 2);SeqListPushBack(&sl, 3);SeqListPushBack(&sl, 4);SeqListPrint(&sl);//头插SeqListPushFront(&sl, 8);SeqListPushFront(&sl, 9);SeqListPushFront(&sl, 10);SeqListPrint(&sl);//在指定位置插入SeqListInsert(&sl, 3, 6);SeqListInsert(&sl, 0, 6);SeqListInsert(&sl, 9, 6);SeqListPrint(&sl);//销毁SeqListDestory(&sl);
}void test2()   //测试删除
{//初始化SL sl;SeqListInit(&sl);//尾插SeqListPushBack(&sl, 1);SeqListPushBack(&sl, 2);SeqListPushBack(&sl, 3);SeqListPushBack(&sl, 4);SeqListPrint(&sl);尾删//SeqListPopBack(&sl);//SeqListPopBack(&sl);//SeqListPopBack(&sl);//SeqListPrint(&sl);头删//SeqListPopFront(&sl);//SeqListPopFront(&sl);//SeqListPopFront(&sl);//SeqListPrint(&sl);//删除指定位置元素SeqListErase(&sl, 3);SeqListPrint(&sl);SeqListErase(&sl, 1);SeqListPrint(&sl);SeqListErase(&sl, 0);SeqListPrint(&sl);//销毁SeqListDestory(&sl);
}void test3()  //测试查和改
{//初始化SL sl;SeqListInit(&sl);//尾插SeqListPushBack(&sl, 1);SeqListPushBack(&sl, 2);SeqListPushBack(&sl, 3);SeqListPushBack(&sl, 4);SeqListPrint(&sl);//查找并修改int find = 0;int modify = 0;do{scanf("%d", &find);  //要查找的元素scanf("%d", &modify);  //要修改的值int pos = SeqListFind(&sl, find);  //查找该元素是否存在if (pos != -1){SeqListModify(&sl, pos, modify);  //存在就修改}SeqListPrint(&sl);} while (find != EOF);//销毁SeqListDestory(&sl);
}//测试函数
int main()
{//test1();  //测试插入//test2();    //测试删除test3();  //测试查和改return 0;
}

大家也可以去我的 Gitee 仓库中获取完整代码：SeqList/SeqList · 野猪佩奇/日常学习 - 码云 - 开源中国 (gitee.com)

---

五、顺序表的缺陷

顺序表存在如下缺陷：

• 在头部/中间的插入与删除需要挪动数据，时间复杂度为O(N)，效率低；
• 增容需要申请新空间，可能会拷贝数据，释放旧空间，会有不小的消耗；
• 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到 200，如果我们再继续插入了5个数据，后面没有数据插入了，那么会浪费95个数据空间；

针对顺序表存在的这些缺陷，我们设计出了链表。

---

六、顺序表力扣OJ题

1、移除元素

题目链接

27. 移除元素 - 力扣（LeetCode）

题目描述

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

思路分析

思路1 – 循环遍历，挪动覆盖数据：遍历这个数组，每当遇见等于val的元素时，就将数组后面的元素整体向前挪动一位。

时间复杂度：O(N^2) 空间复杂度：O(1)。

思路2 – 遍历数组，挪动元素到新空间：开辟一个新的数组，然后遍历原来的数组，将不等于val的元素放入新开辟的数组中，将等于val的元素丢弃；最后让新开辟的数组覆盖掉原数组。

时间复杂度：O(N) 空间复杂度：O(N)。

思路3 -- 遍历数组，挪动覆盖数据（双指针解法）：定义两个指针src 和 dst，最开始都指向数组第一个元素，然后开始遍历数组；如果arr[src] != val，那么让arr[dst] = arr[src]，然后 src++，dst++；如果 arr[src]==val，则 src++，dst不动；这样一直往后遍历，知道把数组所有元素都遍历完。

思路三代码实现

int removeElement(int* nums, int numsSize, int val){int src = 0;int dst = 0;while(src < numsSize){if(nums[src] != val){nums[dst++] = nums[src++];}else{src++;}}return dst;
}

2、删除有序数组中的重复项

题目链接

26. 删除有序数组中的重复项 - 力扣（LeetCode）

题目描述

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

思路分析

这道题的解题思路和上面的移除元素十分相似，都是使用双指针；让 src 和 dst 都指向数组第一个元素，然后判断 arr[src] 和 arr[dst] 是否相等，如果相等，说明是重复元素，则让 src++，dst 不动；如果不相等，就让dst++，然后将 arr[src] 赋给 arr[dst]，再让 src++；然后一直往后遍历数组，直到将数组遍历完。

时间复杂度：O(N) 空间复杂度：O(1)

代码实现

int removeDuplicates(int* nums, int numsSize){int src = 0;int dst = 0;while(src < numsSize){if(nums[src] != nums[dst]){nums[++dst] = nums[src++];  //注意：dst是前置++}else{src++;}}return dst+1;  //由于dst是前置++，所以返回值需要+1 （数组下标从0开始）
}

3、合并两个有序数组

题目链接

88. 合并两个有序数组 - 力扣（LeetCode）

题目描述

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

思路分析

思路1：开辟新数组，并排序：我们可以将两个数组中的元素存放到一个新数组中，然后对数组中的元素进行排序，最后用新数组的数据覆盖掉原数组的数据。

时间复杂度：O((M+N)*log(M+N)) (使用qsort进行排序) 空间复杂度：O(1)。

思路2：开辟新数组，把数据有序的放入数组中（双指针法）：因为两个原数组都是有序的，所以我们可以用两个指针 src1 和 src2 分别指向两个数组，如果src1 指向的元素小于 src2，就把src1的数据放入新数组中然后通过比较大小的方式把数据依次放入新数组中，最后新数组的数据覆盖掉原数组的数据。

思路1代码实现

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){int src1 = 0;int src2 = 0;int dst = 0;int* ret = (int*)calloc(m+n, sizeof(int));while(src1<m && src2<n)  //当达到其中一个数组末尾时停下{if(nums1[src1] > nums2[src2])  //如果数组1中的元素大{ret[dst++] = nums2[src2++];  //将2中的元素赋给新数组}else{ret[dst++] = nums1[src1++];  //否则，将1中的元素赋给新数组}}if(src1 < m)  //如果1中的元素有剩余{while(src1 < m){ret[dst++] = nums1[src1++];}}if(src2 < n)  //如果2中的元素有剩余{while(src2 < n){ret[dst++] = nums2[src2++];}}memcpy(nums1, ret, (m+n)*sizeof(int));  //将1数组中的数据覆盖free(ret);ret = NULL;
}

思路2代码实现

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){int end1 = m - 1;  //指向数组1最后一个有效数据int end2 = n - 1;  //指向数组2末尾int end = m+n-1;   //指向数组1末尾while(end1 >=0 && end2 >= 0)  //当其中一个数组遍历完成后循环结束{if(nums1[end1] < nums2[end2])  //从后往前，需要找大的{nums1[end--] = nums2[end2--];}else{nums1[end--] = nums1[end1--];}}//如果数组1中还有元素则不用管，因为它本来就是有序的；if(end2 >= 0)  //如果数组2还有元素{while(end2 >= 0){nums1[end--] = nums2[end2--];}}
}

---

【数据结构】顺序表的增删查改 (C语言实现)相关推荐

1. C++实现静态顺序表的增删查改以及初始化

   C++实现静态顺序表的增删查改 顺序表:用一段地址连续的存储单元依s次存储数据元素的线性结构,是线性表的一种. //SeqList.h#pragma once#include <assert.h ...

2. 【线性表】—动态顺序表的增删查改实现

   小菜坤日常上传gitee代码:https://gitee.com/qi-dunyan(所有的原码都放在了我上面的gitee仓库里) 数据结构知识点存放在专栏[数据结构]后续会持续更新 ❤❤❤ 个人简介 ...

3. 数据结构C语言实现顺序表——实现增删查改操作完整代码

   #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<asser ...

4. 【详细注释】数据结构 顺序表的增删查 C/C++实现

   前言 顺序表将数据存储在计算机内存中的相邻存储单元内,故结构体内部存储直接使用数组即可. 代码实现 /*** 请注意,由于本次实现需要用到bool变量以及引用,请创建* C++文件而不是C文件*/#i ...

5. 顺序表讲解和顺序表实现增删查改

   前言 顺序表是一种参见的数据结构 特点:类似数组的储存,需要预先开辟空间已备数据插入.(1)同时顺序表也因此会存在和数组同样的问题(例如:越界)(2)同时因为其类似与数组的结构给二分查找这种算法提供了 ...

6. MySQL：带你掌握表的增删查改

   表的增删查改 Create 单行数据 + 全列插入 多行数据 + 指定列插入 插入否则更新 替换 Retrieve SELECT 列 WHERE 条件 结果排序 筛选分页结果 Update Delet ...

7. MySQL - 对数据表进行“增删查改”的基础操作 - 细节狂魔

   文章目录 前文知识点回顾 正文 :对数据表进行"增删查改"操作 新增操作 - insert 关键字 查找语句(基础操作) - select关键字 - 重点!!!!!!!! 1.最基 ...

8. 【MySQL】6.0 表的增删查改

   英语单词 Create 创建 Retrieve 读取 Update 更新 Delete 删除 duplicate 复制 updata 更新数据 replace 替换 constraint 限制 cru ...

9. 【TcaplusDB知识库】GO快速上手PB表的增删查改操作

   PROTOBUF说明 PROTO表是基于PROTOBUF协议设计的TcaplusDB表,PROTOBUF协议是Google开源的通用RPC通信协议,用于TcaplusDB存储数据的序列化.反序列化等操 ...

最新文章

1. 深入理解计算机系统——系统级I/O
2. 安卓界面之Viewpager和Tablayout实现滑动界面
3. SpringBoot集成Druid不支持多条SQL
4. (JAVA)基本数据类型 对象包装类
5. 【Day02】测试 Primise、setTimeout等的执行顺序
6. c++ 十进制、十六进制和BCD的相互转换
7. sqlserver2008索引优化的相关研究（一）
8. 【渝粤教育】国家开放大学2019年春季 1250文论专题 参考试题
9. echarts 地图增加背景图
10. 使用ViewPage + Fragment，ViewPage所在的activity重建时的问题
11. ERROR: HHH000388: Unsuccessful: create table
12. 您未被授权查看该页 您不具备查看该目录或页面的权限，因为访问控制列表 (ACL) 对 Web 服务器上的该资源进行了配置
13. 女神告诉你什么是互联网思维
14. 现如今社群乱象，社群玩法正解
15. C++面向对象实现一个模板类链表
16. 如何降低自动化维护成本？
17. 联想笔记本声音太小怎么办_笔记本声音太小,详细教您笔记本电脑声音太小解决方法...
18. 照明控制系统在呼和浩特商场楼宇的应用
19. 京东口罩到货，邮件实时通知
20. Python语言程序设计 第一周习题

热门文章

1. 小学三年级计算机教学指导思想,2020年小学三年级信息技术教学计划
2. ftp服务器怎么保存文件,FTP服务器保存文件
3. 福田区卫生局社区信息平台
4. 关于激光雷达传感器分类及简介
5. fgets,strlen函数详解
6. 7-3 复数四则运算 C语言
7. Geoserver2.15.0下载，安装与发布地图服务
8. 东呈国际携手东鹏特饮为武汉外卖小哥设立“加油站”
9. BEPUphysicsint碰撞事件详解
10. C++数组，求中位数