代码题-01_顺序表_基础知识

线性表

线性表（list）:零个或多个相同数据元素的有限序列

• 线性表是逻辑结构（元素之间一对一相邻关系）
• 按存储方式分为
  • 顺序表
  • 链表

顺序表

顺序表的定义

• 静态分配（使用数组存数据）
  • 有溢出风险

typedef struct {
    int data[MaxSize]; // 顺序表的数据域
    int length; // 顺序表的当前长度
} SqList;

• 动态分配（使用数组指针存数据）

typedef struct {
    int *data; // 顺序表的数据域
    int length; // 顺序表的当前长度
    int MaxSize; // 顺序表的最大容量
} SqList;

顺序表的特点

• 随机访问、快速找到元素【$O(1)$】
• 存储密度高
• 插入/删除比较麻烦
• 需要连续的存储空间，不够灵活

顺序表的常用操作

• 初始化
• 插入元素【$O(n)$】
• 删除元素【$O(n)$】
• 按值查找【$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]中依次存放两个线性表 (a₁,a₂, a₃,…, a_m) 和(b₁,b₂,b₃,…, b_n)。编写一个函数，将数组中两个顺序表的位置互换，即将(b₁,b₂,b₃,…, b_n)放在(a₁,a₂, a₃,…, a_m) 的前面

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]中依次存放两个线性表 (a₁,a₂, a₃,…, a_m) 和(b₁,b₂,b₃,…, b_n)。编写一个函数，将数组中两个顺序表的位置互换，即将(b₁,b₂,b₃,…, b_n)放在(a₁,a₂, a₃,…, a_m) 的前面

算法思想

• 【算法思想 1】

  • 新建一个临时数组 B，长度为 m+n。将原数组前半部分放入 B 的后半部分，原数组后半部分放入 B 的前半部分，然后将 B 全部赋值给原来的线性表 L

• 【算法思想 2】【2010年】

  • 先将表 (a₁,a₂, a₃,…, a_m)逆置为 (a_m,…, a₃,a₂, a₁,)
  • 再把表(b₁,b₂,b₃,…, b_n)逆置为 (b_n,…, b₃,b₂, b₁,)
  • 再将整个表全部进行逆置，即可得到最终结果

代码实现

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;
    }
}