王道计算机考研 数据结构 课后编程习题代码（绪论、线性表）

第二章、线性表

2.2.3

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)$。
• 思路 ：扫描顺序表L的前半部分元素，对于元素$L.data[i](0<=i<L.length/2)$，将其与后半部分的对应元素$L.data[L.length-i-1]$进行交换。

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

3.

• 题意 ：对长度为n的顺序表L，编写一个时间复杂度为$O(n)$，空间复杂度为$O(1)$的算法，该算法删除线性表中所有值为x的数据元素。
• 解法一 ：用k记录顺序表L中不等于x的元素个数，并将不等于x的元素向前移动k个位置，最后修改L的长度。

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

• 解法二 ：用k记录顺序表L中等于x的元素个数，并将不等于x的元素往前移k个位置，最后修改L的长度。

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

4.

• 题意 ：从有序顺序表中删除其值在给定s与t之间（要求s<t）的所有元素，若s或t不合理或顺序表为空，则显示出错信息并退出运行。
• 思路 ：本题与上一题存在区别。因为是有序表，所以删除的元素必然是相连的整体。先寻找值大于等于s的第一个元素（第一个删除的元素），然后寻找值大于t的第一个元素（最后一个删除的元素的下一个元素），要将这段元素删除，只需直接将后面的元素前移。

bool Del_s_t2(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之间的元素仅移动一次，因此算法效率高。

bool Del_s_t(SqList &L, ElemType s, ElemType t)
{
    if (s >= t || L.length == 0) return false;
    
    int i, k = 0;
    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];
    }
    L.length -= k;
    return true;
}

6.

• 题意 ：从有序顺序表中删除所有值重复的元素，使表中所有元素的值均不同。
• 思路 ：注意是有序顺序表，值相同的元素一定在连续的位置上，用类似于直接插入排序的思想，初始时将第一个元素视为非重复的有序表。之后依次判断后面的元素是否与前面非重复有序表的最后一个元素相同，若相同，则继续向后判断，若不同，则插入前面的非重复有序表的最后，直至判断到表尾为止。

bool Delete_Same(SqList &L)
{
    if (L.length == 0) return false;
    
    int i, j;       // 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(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_m)$和$(b_1,b_2,...,b_n)$。试编写一个函数，将数组中两个顺序表的位置互换，即将$(b_1,b_2,...,b_n)$放在$(a_1,a_2,...,a_m)$的前面。
• 思路 ：先将数组$A[n+m]$中的全部元素$(a_1,a_2,...,a_m,b_1,b_2,...,b_n)$原地逆置为$(b_n,..,b_1,a_m,...,a_1)$，再对前n个元素和后m个元素分别使用逆置算法，即可实现顺序表的位置互换。

typedef int DataType;

void Reverse(DataType A[], int left, int right, int arraySize)
{
    if (right <= left || right >= arraySize) return ;
    
    int mid = (left + right) / 2;
    for (int i = 0; i <= mid - left; i ++ )
    {
        DataType temp = A[left + i];
        A[left + i] = A[right - i];
        A[right - i] = temp;
    }
}

void Exchange(DataType A[], int m, int n, int arraySize)
{
    Reverse(A, 0, m + n - 1, arraySize);
    Reverse(A, 0, n - 1, arraySize);
    Reverse(A, n, m + n - 1, arraySize);
}

9.

• 题意 ：线性表$(a_1,a_2,...,a_n)$中的元素递增有序且按顺序存储于计算机内。要求设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置相交换，若找不到，则将其插入表中并使表中元素仍递增有序。
• 思路 ：顺序存储的线性表递增有序，可以顺序查找，也可以折半查找。题目要求”用最少的时间在表中查找值为x的元素“，这里应该使用折半查找法。

void SearchExchangeInsert(ElemType A[], ElemType x)
{
    int low = 0, high = n - 1, mid;
    while (low <= high)
    {
        mid = (low + high) / 2;
        if (A[mid] == x) break;
        if (A[mid] < x) low = mid + 1;
        else high = mid - 1;
    }
    
    if (A[mid] == x && mid != n - 1)
    {
        t = A[mid], A[mid] = A[mid + 1], A[mid + 1] = t;
    }
    if (low > high)
    {
        for (i = n - 1; i > high; i -- )
            A[i + 1] = A[i];
        A[i + 1] = x;       // A[high + 1] = x;
    }
}

10.

• 2010统考真题
• 题意 ：设将$n(n>1)$个整数存放到一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移$p(0<p<n)$个位置，即将R中的数据由$(X_0,X_1,...,X_{n-1})$变换为$(X_p,X_{p+1},...,X_{n-1},X_0,X_1,...,X_{p-1})$。要求：
• 算法的基本设计思想 ：可将这个问题视为把数组ab转换成数组ba（a代表数组的前p个元素，b代表数组中余下的n-p个元素），先将a逆置得到$a^{-1}b$，然后将b逆置得到$a^{-1}{b}^{-1}$，最后将整个逆置得到$(a^{-1}{b}^{-1}{)}^{-1}=ba$。设Reverse函数执行将数组元素逆置的操作，且两个参数分别表示数组中待转换元素的始末位置。
• 使用C语言描述算法如下 ：

void Reverse(int R[], int from, int to)
{
    int i, temp;
    for (i = 0; i < (to - from + 1) / 2; i ++ )
    {
        temp = R[from + i];
        R[from + i] = R[to - i];
        R[to - i] = temp;
    }
}

void Converse(int R[], int n, int p)
{
    Reverse(R, 0, p - 1);
    Reverse(R, p, n - 1);
    Reverse(R, 0, n - 1);
}

• 上述算法中三个Reverse函数的时间复杂度分别为$O(p/2),O((n-p)/2),O(n/2)$，故所设计的算法的时间复杂度为$O(n)$，空间复杂度为$O(1)$

11.

• 2011统考真题
• 题意 ：一个长度为L$(L>=1)$的升序序列S，处在第$[L/2]$个位置的数称为S的中位数。例如，若序列$S_1=(11,13,15,17,19)$，则$S_1$的中位数是15，两个序列的中位数是含它们所有元素的升序序列的中位数。现在有两个等长升序序列A和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A和B的中位数。要求：

12.

• 2013统考真题
• 题意 ：已知一个整数序列$A=(a_0,a_1,...,a_{n-1})$，其中$0<=a_n<n(0<=i<n)$。若存在$a_{p1}=a_{p2}==...=a_{pm}=x$且m>n/2$(0,=p_k<n,1<=k<=m)$，则称x为A的主元素。例如…。假设A中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出A的主严肃，若存在则输出，否则输出-1。要求：

13.

• 2018统考真题
• 题意 ：给定一个含n(n>=1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。要求 ：

14.

• 2020统考真题
• 题意 ：定义三元组$(a,b,c)$（a，b，c均为正数）的距离$D=|a-b|+|b-c|+|c-a|$。给定三个非空整数集合$S_1,S_2,S_3$，按升序分别存储在3个数组中，请设计一个尽可能高效的算法，计算并输出所有可能的三元组$(a,b,c)(a属于S_1，b属于S_2，c属于S_3)$中的最小距离。要求 ：