【计算机考研·数据结构】线性表的顺序表示·程序设计题

题目出处：王道考研2022年数据结构考研复习指导
本篇博客中所有题目代码均使用C++语言。

---

1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删函数的值。空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。

遍历顺序表，记录最小值元素及其位置，遍历结束后用最后一个元素填补到记录的位置，顺序表长度减1。

bool del_min(SqList& L, ElemType& value) {
   
    if (L.length == 0) {
   
        // 显示出错信息
        return false;
    }
    value = L.data[0];
    int pos = 0;
    for (int i = 1; i < L.length; i++) {
   
        if (L.data[i] < value) {
   
            value = L.data[i];
            pos = i;
        }
    }
    L.data[pos] = L.data[L.length - 1];
    L.length--;
    return true;
}

2.设计一个高效算法，将顺序表 $L$ 的所有元素逆置，要求算法的空间复杂度为 $O(1)$。

遍历顺序表前半部分元素，将其与后半部分对应元素进行交换。

void Reverse(SqList& L) {
   
    ElemType t;
    for (int i = 0; i < L.length / 2; i++) {
   
        t = L.data[i];
        L.data[i] = L.data[L.length - i - 1];
        L.data[L.length - i - 1] = t;
    }
}

3.对长度为 $n$ 的顺序表 $L$，编写一个时间复杂度为 $O(n)$、空间复杂度为 $O(1)$ 的算法，该算法删除线性表中所有值为 $x$ 的数据元素。

方法1：边遍历顺序表边记录顺序表中不等于 $x$ 的元素个数cnt，将其向前移动cnt个位置，最后修改顺序表长度。

void del_x(SqList& L, Elemtype x) {
   
    int cnt = 0;
    for (int i = 0; i < L.length; i++) {
   
        if (L.data[i] != x) {
   
            L.data[cnt++] = L.data[i];
        }
    }
    L.length = cnt;
}

方法2：边遍历顺序表边记录顺序表中等于 $x$ 的元素个数cnt，将不等于 $x$ 的元素向前移动cnt个位置，最后修改顺序表长度。

void del_x(SqList& L, ElemType x) {
   
    int cnt = 0, i = 0;
    while (i < L.length) {
   
        if (L.data[i] == x) {
   
            cnt++;
        } else {
   
            L.data[i - cnt] = L.data[i];
        }
        i++;
    }
    L.length -= cnt;
}

4.从有序顺序表中删除其值在给定值 $s$ 与 $t$ 之间（要求 $s<t$）的所有元素，若 $s$ 或 $t$ 不合理或顺序表为空，则显示出错信息并退出运行。

寻找值大于或等于 $s$ 的第一个元素，然后寻找值大于 $t$ 的第一个元素，将这段元素删除。

bool del_s_t(SqList& L, ElemType s, ElemType t) {
   
    if (s >= t || L.length == 0) {
   
        // 显示出错信息
        return false;
    }
    int i, j;
    for (i = 0; i < L.length && L.data[i] < s; i++);
    if (i >= L.length) {
   
        // 显示出错信息
        return false;
    }
    for (j = i; j < L.length && L.data[j] <= t; j++);
    for (; j < L.length; i++, j++) {
   
        L.data[i] = L.data[j];
    }
    L.length = i;
    return true;
}

5.从顺序表中删除其值在给定值 $s$ 与 $t$ 之间（包含 $s$ 和 $t$，要求 $s<t$）的所有元素，若 $s$ 或 $t$ 不合理或顺序表为空，则显示出错信息并退出运行。

遍历顺序表，记录元素值在 $s$ 与 $t$ 之间元素的个数cnt，对于当前元素，若其值不在 $s$ 与 $t$ 之间，则前移cnt个位置，否则执行cnt++。

bool del_s_t(SqList& L, ElemType s, ElemType t) {
   
    int cnt = 0;
    if (s >= t || L.length == 0) {
   
        // 显示出错信息
        return false;
    }
    for (int i = 0; i < L.length; i++) {
   
        if (L.data[i] >= s && L.data[i] <= t) {
   
            cnt++;
        } else {
   
            L.data[i - cnt] = L.data[i];
        }
    }
    L.length -= k;
    return true;
}

6.从有序顺序表中删除所有其值重复的元素，使表中所有元素的值均不同。

初始时将第一个元素视为非重复有序表，依次判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同则继续向后判断，若不同则插入前面的非重复有序表的最后，直至判断到表尾。

bool del_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]) {
   
            L.data[++i] = L.data[j];
        }
    }
    L.length = i + 1;
    return true;
}

7.将两个有序顺序表合并为一个新的有序顺序表，并由函数返回结果顺序表。

按顺序不断取两表表头较小的元素存入新的顺序表，上述流程结束后将有剩余元素的那个表中的元素存入新的顺序表。

bool merge_list(SqList A, SqList B, SqList& C) {
   
    if (A.length + B.length > C.MaxSize) {
   
        return false;
    }
    int i = 0, j = 0, k = 0;
    while (i < A.length && j < B.length) {
   
        if (A.data[i] <= B.data[j]) {
   
            C.data[k++] = A.data[i++];
        } else {
   
            C.data[k++] = B.data[j++];
        }
    }
    while (i < A.length) {
   
        C.data[k++] = A.data[i++];
    }
    while (j < B.length) {
   
        C.data[k++] = B.data[j++];
    }
    C.length = k;
    return true;
}

8.已知在一维数组 $A[m+n]$ 中依次存放两个线性表 $(a_1,a_2,a_3,\cdots ,a_m)$ 和