线性表
线性表（list）:零个或多个相同数据元素的有限序列
- 线性表是逻辑结构（元素之间一对一相邻关系）
- 按存储方式分为
- 顺序表
- 链表
顺序表
顺序表的定义
- 静态分配（使用数组存数据）
- 有溢出风险
typedef struct {
int data[MaxSize]; // 顺序表的数据域
int length; // 顺序表的当前长度
} SqList;
- 动态分配（使用数组指针存数据）
typedef struct {
int *data; // 顺序表的数据域
int length; // 顺序表的当前长度
int MaxSize; // 顺序表的最大容量
} SqList;
顺序表的特点
- 随机访问、快速找到元素【 O ( 1 ) O(1) O(1)】
- 存储密度高
- 插入/删除比较麻烦
- 需要连续的存储空间，不够灵活
顺序表的常用操作
- 初始化
- 插入元素【 O ( n ) O(n) O(n)】
- 删除元素【 O ( n ) O(n) O(n)】
- 按值查找【 O ( 1 ) O(1) O(1)】
增、删、改、查直接类比对数组的操作，不再给出操作代码
练习使用顺序表
- 1、设计一个高效算法，将顺序表 L 中所有元素逆置
- 2、从顺序表中删除具有最小值的元素（假设唯一）并由引用参数返回被删除元素的值，函数返回删除是否成功，空出的位置由最后一个元素填补
- 3、对长度为n的顺序表L，编写一个时间复杂度为 O(n)，空间复杂度为 O(1)的算法，该算法删除线性表中所有值为x的数据元素
- 4、从顺序表中删除其值在给定值 s 与 t 之间（包含 s 和 t，要求 s < t）的所有元素，若 s 或 t 不合理或顺序表为空，则显示出错信息并退出运行
- 5、从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同
- 6、从有序顺序表中删除其值在给定值 s 与 t 之间（ 要求 s<t）的所有元素，若 s 或 t 不合理或顺序表为空，则显示出错信息并退出运行
- 7、将两个有序顺序表合并为一个新的有序顺序表(从小到大)，并由函数返回结果顺序表
- 8、已知在一维数组 A[m+n]中依次存放两个线性表 (a1,a2, a3,…, am) 和(b1,b2,b3,…, bn)。编写一个函数，将数组中两个顺序表的位置互换，即将(b1,b2,b3,…, bn)放在(a1,a2, a3,…, am) 的前面
1、设计一个高效算法，将顺序表 L 中所有元素逆置
算法思想
将顺序表分为两个部分，设置中间变量，用来记录首尾两个元素的位置。
具体步骤：
- 先扫描表 L 的前半部分元素
- 对于元素
L.data[i]将其与后半部分对应元素L.data[L.length-i-1]进行交换 - 利用一个中间变量实现
代码实现
void ListReverse(Sqlist &L)
{
for (int i = 0; i < L.length / 2;i ++) // 前半部分与后半部分交换，只需遍历一半
{
int temp = L.data[i]; // 交换数据，用某个中间变量实现，可以把变量的定义和操作写在一行
L.data[i] = L.data[L.length - i - 1]; // 将第i个元素与后半部分相对位置的元素交换位置
L.data[L.length - i - 1] = temp; // 将中间变量赋给后半部分相对位置的元素，进行下一次循环
}
}
2、从顺序表中删除具有最小值的元素（假设唯一）并由引用参数返回被删除元素的值，函数返回删除是否成功，空出的位置由最后一个元素填补
算法思想
- 查看顺序表是否合法，不合法直接返回，删除失败
- 搜素整个顺序表，查找最小值元素并记录位置
- 搜索结束后用最后一个元素填补空出的原最小值元素的位置
代码实现
// 删除顺序表L中的最小值元素，并通过引用参数value返回其值
bool Delete_Min(SqList &L, int &value) {
if (L.length == 0) { // 顺序表为空
return false;
}
value = L.data[0];//假设 0 号元素的值最小
int pos = 0;
for (int i = 1; i < L.length; i++) {
if (L.data[i] < value) {
pos = i;
}
}
L.data[pos] = L.data[L.length - 1]; // 用最后一个元素填补空位
L.length--; // 顺序表长度减1
return true;
}
3、对长度为n的顺序表L，编写一个时间复杂度为 O(n)，空间复杂度为 O(1)的算法，该算法删除线性表中所有值为x的数据元素
算法思想
- 用 j 记录顺序表 L 中等于 x 的元素个数
- 将不等于 x 的元素前移
- 最后修改 L 的长度
代码实现
void del_x(SqList &L, int x) {
int i = 0, j = 0;
while(i < L.length){
if(L.data[i] == x)
j++;
else //将不等于x的元素向前移动j个位置
L.data[i - j] = L.data[i]
i++;
}
L.length = L.length - j; // 更新长度
}
4、从顺序表中删除其值在给定值 s 与 t 之间（包含 s 和 t，要求 s < t）的所有元素，若 s 或 t 不合理或顺序表为空，则显示出错信息并退出运行
算法思想
-
该顺序表不一定有序
-
从前向后扫描顺序表 L，用 k 记录下元素值在 s 到 t 之间元素的个数
-
对于当前扫描的元素
- 若其值不在 s 到 t 之间，则前移 k 个位置
- 否则执行 k++
-
每一个不在 s 到 t 之间的元素仅移动一次
代码实现
bool del_st(SqList &L, int s, int t) {
int i = 0, k = 0;
// 判断线性表是否合法
if(L.length == 0 || s >= t)
return false;
for (i = 0; i < L.length; i++) {
if (L.data[i] >= s && L.data[i] <= t)
k++;
else
L.data[i - k] = L.data[i] // 将不等于 s 的元素向前移动 k 个位置
}
L.length = L.length - k; // 更新长度
return true;
}
5、从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同
算法思想
- 有序顺序表，值相同的元素一定在连续的位置上，用类似于直接插入排序的思想
- 初始时将第一个元素视为非重复的有序表
- 依次判断后面的元素是否与前面非重复有序表的最后一个元素相同
- 若相同，则继续向后判断；
- 若不同，则插入前面的非重复有序表的最后，直至判断到表尾为止
双指针，快指针遍历整个顺序表，慢指针指向无重复元素表的最后
代码实现
bool Delete_Same(SqList &L) {
// 判断线性表是否合法
if(L.length == 0)
return false;
int i, j;
for (i = 0, j = 1; j < L.length; j++) {
if (L.data[i] != L.data[j]) // i的位置是无重复表的最后一个位置
L.data[++i] = L.data[j] //不能写成i++，这里需要先让i指向一个新的空白位置，再放数据
}
L.length = i + 1; // 更新长度
return true;
}
6、从有序顺序表中删除其值在给定值 s 与 t 之间（ 要求 s<t）的所有元素，若 s 或 t 不合理或顺序表为空，则显示出错信息并退出运行
算法思想
- 有序表，所以可以快速确定临界元素的位置
- 先寻找值
>= s的第一个元素l，也就是第一个要删除的元素 - 然后寻找值
>= t的第一个元素r(最后一个删除的元素的下一个元素) - 将 r 及其后面的元素前移，即可删除 s 与 t 之间（ 要求 s<t）的所有元素
代码实现
bool del(SqList &L, int s, int t) {
//判断s和t是否合理、顺序表是否为空
if (s >= t || L.length == 0)
return false;
int l = 0, r = L.length - 1;
for (l = 0; l < L.length && L.data[l] < s; l++); // 找到第一个大于等于s的元素
while (r >= l && L.data[r] > t)
r--;
r = r + 1; // 找到第一个大于t的元素
int i = l, j = r;
while (j < L.length) {
L.data[i++] = L.data[j++]; // 将后面的元素前移
}
L.length = L.length - r + l; // 更新顺序表长度
return true;
}
7、将两个有序顺序表合并为一个新的有序顺序表(从小到大)，并由函数返回结果顺序表
算法思想
不合并相同的项
- A和B中较小的元素放入C中
- 设置两个指针指向A、B的开始
- 比较这两个指针所指的元素
- 将较小的数据存入到C中，然后后移该指针
- 直到某一个表被遍历完就不再继续
- A或B中剩余的元素放入C中
- 将剩余的元素之间放到C的后面即可
下面给出第一个循环的示意图：
代码实现
bool Merge(SqList A, SqList B, SqList &C) {
if (C.maxSize < A.length + B.length) {
// C的存储空间不足
return false;
}
int i = 0, j = 0, k = 0;
while (i < A.length && j < B.length) {
// 比较A和B中的元素，将较小的元素放入C中
if (A.data[i] <= B.data[j]) {
C.data[k++] = A.data[i++];
} else {
C.data[k++] = B.data[j++];
}
}
while (i < A.length) { // A中还有元素
C.data[k++] = A.data[i++];
}
while (j < B.length) { // B中还有元素
C.data[k++] = B.data[j++];
}
C.length = k;
return true;
}
8、已知在一维数组 A[m+n]中依次存放两个线性表 (a1,a2, a3,…, am) 和(b1,b2,b3,…, bn)。编写一个函数，将数组中两个顺序表的位置互换，即将(b1,b2,b3,…, bn)放在(a1,a2, a3,…, am) 的前面
算法思想
-
【算法思想 1】
- 新建一个临时数组 B，长度为 m+n。将原数组前半部分放入 B 的后半部分，原数组后半部分放入 B 的前半部分，然后将 B 全部赋值给原来的线性表 L
-
【算法思想 2】【2010年】
- 先将表 (a1,a2, a3,…, am)逆置为 (am,…, a3,a2, a1,)
- 再把表(b1,b2,b3,…, bn)逆置为 (bn,…, b3,b2, b1,)
- 再将整个表全部进行逆置，即可得到最终结果
代码实现
void Exchange1(SqList &L, int m, int n) {
int B[m + n];
// 将线性表 L 的前半部分放入 B 数组的后半部分
for (int i = 0; i < m; i++) {
B[n + i] = L.data[i];
}
// 将线性表 L 的后半部分放入 B 数组的前半部分
for (int i = 0; i < n; i++) {
B[i] = L.data[m + i];
}
// 将 B 数组全部复制给线性表 L
for (int i = 0; i < L.length; i++) {
L.data[i] = B[i];
}
}
void Exchange2(SqList &L, int m, int n) {
if (m + n != L.length)
return;
int temp;
//逆置顺序表前半部分位置元素
for (int i = 0; i < m / 2; i++) {
temp = L.data[i];
L.data[i] = L.data[m - 1 - i];
L.data[m - 1 - i] = temp;
}
// 逆置顺序表后半部分位置元素
for (int i = 0; i < n / 2; i++) {
temp = L.data[m + i];
L.data[m + i] = L.data[L.length - 1 - i];
L.data[L.length - 1 - i] = temp;
}
// 逆置整个顺序表
for (int i = 0; i < L.length / 2; i++) {
temp = L.data[i];
L.data[i] = L.data[L.length - 1 - i];
L.data[L.length - 1 - i] = temp;
}
}
