JOB3：顺序表的应用算法

顺序表常用算法解析

原创已于 2025-11-10 18:17:00 修改 · 647 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #开发语言

于 2025-11-10 18:12:04 首次发布

数据结构C++ 专栏收录该内容

2 篇文章

订阅专栏

编程达人挑战赛·第3期 10w+人浏览 221人参与

JOB3

实验内容：

1.设计算法，将顺序表L中的所有元素逆置；

void Reverse(SqList<T>& L){...}

2.设计算法，删除顺序表L中所有值为x的元素；

void Deletex1(SqList<T> & L, int x){...}

3.设计算法，删除顺序表L中从序号i开始的k个元素

bool Deletek(SqList<T>& L, int i, int k){...}

4.设计算法，合并两个按元素值递增有序的顺序表A和B中的全部元素，得到新的顺序表C

void Merge2(SqList<T> A, SqList<T> B, SqList<T>& C){...}

[该算法也可理解为：求两个用顺序表表示的集合A和B的并集C。]

选做题：如何求两集合的差集和交集呢？请你来思考。

5.设计算法，在有序顺序表L中插入元素e，使得该顺序表依然有序

提示：若顺序表满，则插入失败；否则正常执行插入操作。

bool Insert(SqList<T>& L, T e){...}

6.设计算法，将顺序表L中所有值为奇数的元素移动其他元素的前面。

void Move(SqList<T> &L){...}

Job3_SqList_2.cpp 算法应用分析

1. 包含与声明

分析：

include "SqList.cpp"：包含了我们之前分析过的 SqList 类的完整实现。
include <iostream> 和 using namespace std;：用于算法中的 swap（在 Reverse 和 Move 中）以及 main 函数中的 cout。

对应代码：

C++

include "SqList.cpp" //引用顺序表泛型类

include <iostream>

using namespace std;

2. 算法1：Reverse (顺序表逆置)

分析：

目标 (JOB3-1)：将顺序表L中的所有元素原地逆置。
实现： 使用了双指针法。
- int i = 0, j = L.length - 1;：指针 i 指向表头，指针 j 指向表尾。
- while (i < j)：当两个指针相遇或交错时，逆置完成。
- swap(L.data[i], L.data[j]);：交换 i 和 j 指向的元素。
- i++; j--;：两个指针向中间移动。
记忆技巧： “两头对调，向内收缩”。

对应代码：

C++

//将顺序表L中的所有元素逆置

template <typename T>

void Reverse(SqList<T>& L)

{

int i = 0, j = L.length - 1;

while (i < j)

{

swap(L.data[i], L.data[j]); //序号为i和j的两个元素交换

i++;

j--;

}

3. 算法2：Deletex1 (删除所有值为x的元素)

分析：

目标 (JOB3-2)：删除顺序表L中所有值为 x 的元素。
实现： 使用了快慢指针法（或称为“压缩法”）。
- int k = 0;：k 是慢指针，指向下一个“非x元素”应该存放的位置。
- for (int i = 0; i < L.length; i++)：i 是快指针，负责遍历整个数组。
- if (L.data[i] != x)：如果快指针 i 找到了一个不等于 x 的元素。
- L.data[k] = L.data[i]; k++;：就将其“保留”，放到慢指针 k 的位置，然后 k 后移一位。
- L.length = k;：遍历结束后，k 的值就是新数组的实际长度（所有 x 都被跳过了）。
记忆技巧： “快指针 i 找，慢指针 k 存”。

对应代码：

C++

//删除顺序表L中所有值为x的元素

template <typename T>

void Deletex1(SqList<T> & L, int x)

{

int k = 0;

for (int i = 0; i < L.length; i++)

if (L.data[i] != x) //将不为x的元素插入到data中

{

L.data[k] = L.data[i];

k++;

}

L.length = k; //重置L的长度为k

}

4. 算法3：Deletek (删除从i开始的k个元素)

分析：

目标 (JOB3-3)：删除顺序表L中从序号 i 开始的 k 个元素。
实现： 利用了顺序表元素前移的特性。
- if (i < 0 || k < 1 || ...)：严格的参数检查，确保 i 和 k 的范围合法。
- for (int j = i + k; j < L.length; j++)：j 从被删除区域的后面第一个元素 (i+k) 开始遍历。
- L.data[j - k] = L.data[j];：将 j 位置的元素向前移动 k 个位置，覆盖掉 j-k 位置的元素。
- L.length -= k;：最后，总长度减少 k。
记忆技巧： “跳过 k 个，后面 (j) 的搬到前面 (j-k)”。

对应代码：

C++

//删除顺序表L中从序号i开始的k个元素

template <typename T>

bool Deletek(SqList<T>& L, int i, int k) //求解算法

{

if (i < 0 || k < 1 || i + k<1 || i + k>L.length)

return false; //参数i和k错误返回false

for (int j = i + k; j < L.length; j++) //删除k个元素

L.data[j - k] = L.data[j];

L.length -= k; //长度减k

return true;

}

5. 算法4：Merge2 (合并两个有序顺序表)

分析：

目标 (JOB3-4)：合并两个递增有序的顺序表A和B到C。
实现： 类似“归并排序”的合并步骤。
- int i = 0, j = 0;：i 遍历 A，j 遍历 B。
- while (i < A.length && j < B.length)：当两个表都未遍历完时。
- if (A.data[i] < B.data[j]) ... else ...：比较 A[i] 和 B[j] 的大小，将较小的那个元素用 C.Add() 添加到 C 的末尾，并移动对应的指针（i++ 或 j++）。
- while (i < A.length) 和 while (j < B.length)：处理其中一个表遍历完后，另一个表剩余的元素，将它们全部 Add 到 C 中。
记忆技巧： “双指针 i j 比大小，小的进 C，指针走。最后处理剩（Sheng）利（Li）者。”

对应代码：

C++

//合并两个按元素值递增有序的顺序表A和B中的全部元素，得到新的顺序表C

template <typename T>

void Merge2(SqList<T> A, SqList<T> B, SqList<T>& C)

{

int i = 0, j = 0; //i用于遍历A,j用于遍历B

while (i < A.length && j < B.length) //两个表均没有遍历完毕

{

if (A.data[i] < B.data[j])

{

C.Add(A.data[i]); //归并A[i]:将较小的A[i]添加到C中

i++;

}

else //归并B[j]:将较小的B[j]添加到C中

{

C.Add(B.data[j]);

j++;

}

while (i < A.length) //若A没有遍历完毕

{

C.Add(A.data[i]); //归并A中剩余元素

i++;

}

while (j < B.length) //若B没有遍历完毕

{

C.Add(B.data[j]); //归并B中剩余元素

j++;

}

6. 算法5：Insert (有序表插入)

分析：

目标 (JOB3-5)：在有序顺序表L中插入元素 e，使其依然有序。
实现：
- if (L.length == L.capacity) return false;：检查表是否已满，满了则插入失败。
- int i = 0; while (i < L.length && L.data[i] <= e)：循环查找第一个大于 e 的元素位置 i。
- for (int j = L.length; j > i; j--) ...：将从 i 位置开始的所有元素向后移动一位（这与 SqList.cpp 中的 Insert 逻辑相同）。
- L.data[i] = e;：在腾出的 i 位置放入 e。
记忆技巧： “先找到 i (第一个比 e 大的)，再从后往前移到 i，最后 i 处放 e”。

对应代码：

C++

template <typename T>

bool Insert(SqList<T>& L, T e)

{

if (L.length == L.capacity) // 顺序表空间满时，插入操作被禁止

return false;

int i = 0;

while (i < L.length&& L.data[i] <= e) // 找到第一个大于e的元素的位置

i++;

for (int j = L.length; j > i; j--) // 将data[i]及后面元素后移一个位置

L.data[j] = L.data[j - 1];

L.data[i] = e; // 插入元素e

L.length++; // 长度增1

return true;

}

7. 算法6：Move (奇数移动到前面)

分析：

目标 (JOB3-6)：将顺序表L中所有奇数移动到其他元素（偶数）的前面。
实现： 类似“快速排序”的 partition 思想，但使用了 swap。
- int i = -1;：i 指向“奇数区”的最后一个元素。
- int j = 0;：j 负责遍历整个数组。
- while (j < L.length)：遍历。
- if (L.data[j] % 2 == 1)：如果 j 找到了一个奇数。
- i++;：将“奇数区”向后扩大一位。
- if (i != j) swap(L.data[i], L.data[j]);：关键：如果 i 和 j 不在同一位置，就将 j 找到的奇数与 i 位置的元素（必然是偶数或 j 自身）交换。
- j++;：j 继续向后遍历。
记忆技巧： “j 探路，i 守城（奇数区）。j 遇奇数，i 扩城，swap(i, j)”。

对应代码：

C++

template <typename T>

void Move(SqList<T> & L) {

int i = -1;

int j = 0;

while (j < L.length) {

if (L.data[j] % 2 == 1) {

i++;

if (i != j)

swap(L.data[i], L.data[j]);

}

j++;

}

8. main 函数 (测试流程)

分析： main 函数按顺序调用了上述所有算法，以验证它们的正确性。

创建 L：使用数组 a 创建 L。
测试 Reverse：调用 Reverse(L) 并显示结果。
测试 Deletex1：连续两次调用 Deletex1(L, 1) 和 Deletex1(L, 2)，删除所有1和2。
测试 Deletek：调用 Deletek(L, 3, 2)，删除从序号3开始的2个元素。
创建 S：使用数组 b 创建 S。
测试 Merge2：调用 Merge2(L, S, C)，合并 L 和 S 到 C。
测试 Insert：调用 Insert(C, 13)，在有序表 C 中插入13。
测试 Move：调用 Move(C)，将 C 中的奇数移到前面。
销毁： 程序结束，L, S, C 的析构函数被调用。

对应代码：

C++

int main()

{

       int i;

       int start;

       int count;

       int a[] = { 1,20,18,2,2,16,10,8,6,1,3,2,2,1,1,1};

       int n = sizeof(a) / sizeof(a[0]);

       SqList<int> L;             //建立元素类型为int的顺序表对象L

       cout << "由数组a创建顺序表L" << endl;

       L.CreateList(a, n);

       cout << "顺序表L:";

       L.DispList();



       cout << "逆置顺序表L" << endl;

       Reverse(L);

       cout << "逆置后，顺序表L:";

       L.DispList();

       cout << endl;



       i = 1;

       cout << "删除顺序表L中所有值为"<<i<<"的元素" << endl;

       Deletex1(L, i);

       cout << "操作后，顺序表L:";

       L.DispList();

       cout << endl;



       i = 2;

       cout << "删除顺序表L中所有值为" << i << "的元素" << endl;

       Deletex1(L, i);

       cout << "操作后，顺序表L:";

       L.DispList();

       cout << "顺序表L的长度是:" << L.length << ",顺序表L的容量是:" << L.capacity << endl;

       cout << endl;



       start = 3;

       count = 2;

       cout << "删除顺序表L中从序号" << start << "起的" << count << "个元素" << endl;

       Deletek(L, start, count);

       cout << "操作后，顺序表L:";

       L.DispList();

       cout << "顺序表L的长度是:" << L.length << ",顺序表L的容量是:" << L.capacity << endl;

       cout << endl;





       int b[] = { 4,5,7,9,11,17 };

       int m = sizeof(b) / sizeof(b[0]);

       SqList<int> S;              //建立元素类型为int的顺序表对象L

       cout << "由数组b创建顺序表S" << endl;

       S.CreateList(b, m);

       cout << "顺序表S:";

       S.DispList();

       cout << endl;

       cout << "合并顺序表L和顺序表S，得到一个新的顺序表C" << endl;

       SqList<int> C;

       Merge2(L, S, C);



       cout << "操作后，顺序表C:";

       C.DispList();

       cout << "顺序表C的长度是:" << C.length << ",顺序表C的容量是:" << C.capacity << endl;

       cout << endl;



       i = 13;

       cout << "在有序顺序表C中插入元素" << i << ",得到的顺序表C";

       Insert(C, i);

       cout << "操作后，顺序表C:";

       C.DispList();

       cout << "顺序表C的长度是:" << C.length << ",顺序表C的容量是:" << C.capacity << endl;

       cout << endl;





       cout << "将顺序表C中的奇数移到其他元素的前面，得到顺序表C：";

       Move(C);

       cout << "操作后，顺序表C:";

       C.DispList();

       cout << "顺序表L的长度是:" << C.length << ",顺序表L的容量是:" << L.capacity << endl;

       cout << endl;



       cout << "销毁顺序表..." << endl;

       return 0;

}