王道22数据结构课后习题（第二章2.2.3）

已于 2022-11-28 23:28:28 修改
阅读量2.7k 收藏 28
点赞数 5
文章标签： c++ c语言 数据结构
于 2022-03-30 14:35:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50679120/article/details/123750696
版权

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

//删除顺序表L中的最小值元素结点，并通过引用类型参数e返回其值
bool Del_min(SqList &L, int &e)
{
    if(L.length == 0)
        return false;
    int pos = 0
    e = L.data[0];
    for(i = 0 ; i < L.length; i++)
    {
        if(L.data[i] < e)
        {
            e = L.data[i];
            pos = i;
        }
    }
    L.data[pos] = L.data[L.length - 1];
    L.length--;
    return true;
}

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

//将顺序表L的所有元素逆置，空间复杂度为O(1)
void Reverse(SqList &L)
{
    int temp;
    for(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;
    }
}

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

void del_x_1(SqList &L, int 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;
}

4、从有序顺序表中删除其值在[s,t]之间的所有元素，若s或t不合理或顺序表为空，则显示出错误信息并退出运行。

解法一（有点暴力）：

//有序顺序表中删除其值在[s,t]之间的所有元素
bool Del_s_t2(SqList &L, int s, int t)
{
    int k = 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))
        {
            L.data[k] = L.data[i]；
            k++;
        }
    }
    L.length = k;
}

解法二（基于有序的最优解）：

bool Del_s_t2(SqList &L, int s, int t)
{
    int i, j;
    if(s >= t || L.length == 0)
        return false;
    for(i = 0; i < L.length && L.data[i] < s; i++);  //寻找大于等于s的第一个元素
    if(i >= L.length)
        return false;
    for(j = i; j < L.length && L.data[j] <= t; j++); //寻找第一个大于t的元素
    for(;j < L.length; i++, j++)
        L.data[i] = L.data[j];
    L.length = i;
    return true;
}

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

也许暴力解就是最优解，和上一题的第一种解法相同：

bool Del_s_t2(SqList &L， int s, int t)
{
    int k = 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))
        {
            L.data[k] = L.data[i];
            k++;
        }
    }
    L.length = k;
}

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

//有序表中删除所有值相同的元素(保留一个）
void Delete_Same(SqList &L)
{
    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;
}

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]中依次存放两个线性表(a1,a2,a3~am)和(b1,b2,b3~bn)。编写一个函数，将数组中两个顺序表的位置互换，即将(b1,b2,b3~bn)放在(a1,a2,a3~an)前面。

垃圾的暴力解：将A[0]与A[m]互换，再将A[1]与A[m+1]互换，一直到将A[m-1]与A[m+n-1]互换，如果此时A[m+n-1]之后还有元素，说明n>m，则把这些元素全部放到A[m]及之后的位置，将已调整的元素往后移。

最优解：将A[m+n]中的元素全部逆置，再将前n个元素与后m个元素分别使用逆置算法。

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

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

9、线性表（a1,a2,a3~an）中的元素递增有序且按顺序存储与计算机内，要求设计一个算法，完成用最少时间在表中查找数值为x的元素，并将其与后继元素位置交换。若找不到，则将其插入表中并使表中元素仍递增有序。

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

10、设将n（n>1）个整数存到一维数组R中。设计一个在时间和空间两方面都尽可能高效的算法。将R中保存的序列循环左移p（0<p<n）个位置，即将R中的数据由（X0,X1,~,Xn-1）变换为（Xp,Xp+1,~,Xn-1,X0,X1,~,Xp-1）。要求：

（1）给出算法的基本设计思想。

（2）根据设计思想，采用C或C++或Java语言描述算法，关键之处给出注释。

（3）说明你所设计算法的时间复杂度和空间复杂度。

解法一（暴力解）

/*基本设计思想：用t保存数组首元素，将其余元素向左移动一个单位，
  再将数组首元素加到末尾，即完成了循环左移一位。这样进行p次即完
  成了循环左移p位。*/

//时间复杂度为O(pn)即O(n)，空间复杂度为O(1)。

#include <iostream>

using namespace std;

int main()
{
    int R[5] = {1, 2, 3, 4, 5};
    int len = 5, p = 0;
    scanf("%d", &p);
    for(int i = 0; i < p; i++)
    {
        int t = R[0];
        for(int j = 1; j < 5; j++)
            R[j - 1] = R[j];
        R[4] = t;
    }
    for(int i = 0; i < 5; i++)
        printf("%d", R[i]);

}

解法二（最优解）：

/*可以将问题是为把数组ab转换为ba（a为前n个元素，b后n-p个元素），
  先将a逆置，再将b逆置，然后对新数组再整体逆置即可。*/
  
/*三个Reverse时间复杂度为O(p/2),O((n-p)/2),O(n/2)，故为O(1)，
  空间复杂度为O(1)。*/

void Reverse(int R[], int from, int to)
{
    int temp;
    for(int i = from; i < (from + to)/2; i++)
    {
        temp = R[i];
        R[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);
    for(int i = 0; i < 5; i++)
    {
        printf("%d", R[i]);
    }
}

11、题目略

编了一下午的次优解：

/*A和B两个序列，用i遍历A，用j遍历B，当A[i]<B[j]时，
  假装将其装入一个升序序列中，用pos表示其中的元素，
  是谁最后时pos变成(L/2)向上取整，就将谁打印出来。*/

/*时间复杂度为O(n)，空间复杂度为O(1)*/

#include <iostream>

using namespace std;


int Merge(int A[], int B[])
{
    int pos = 0, j = 0, i = 0;

    while(j < 5 && i < 5)
    {
        if(A[i] > B[j])
        {
            j++;
            pos++;    //记录元素的位序
            if(pos == (10 + 2 - 1)/2)
            {
                printf("%d\n", pos);
                return B[j - 1];
            }
        }
        else
        {
            i++;
            pos++;
            if(pos == (10 + 2 - 1)/2)
            {
                printf("%d\n", pos);
                return A[i - 1];
            }
        }
    }
    while(i < 5)
    {
        pos++;
        if(pos == (10 + 2 - 1)/2)
            {
                printf("%d\n", pos);
                return A[i - 1];
            }
        i++;
    }
    while(j < 5)
    {
        pos++;
        if(pos == (10 + 2 - 1)/2)
            {
                printf("%d\n", pos);
                return B[j - 1];
            }
        j++;
    }
}

int main()
{
    int z;
    int S1[5] = {1, 3, 5, 7, 9};
    int S2[5] = {11, 13, 15, 17, 19};
    z = Merge(S1,S2);
    printf("%d",z);
}

暴力解：

/*暴力解就是额外设置一个数组C用来存放已排好序的队列，
  再求其中位数，因为两个等长序列，故数组C长度为偶数，
  中位数为L/2*/

/*时间复杂度为O(n)，空间复杂度为O(n)*/

#include <iostream>

using namespace std;


int Merge(int A[], int B[])
{
    int i = 0, j = 0, k = 0, C[12];
    while(i < 6 && j < 6)
    {
        if(A[i] <= B[j])
            C[k++] = A[i++];
        else
            C[k++] = B[j++];
    }
    while(i < 6)
        C[k++] = A[i++];
    while(j < 6)
        C[k++] = B[j++];
    return C[k / 2];
}

int main()
{
    int z;
    int S1[6] = {1, 3, 5, 7, 9,10};
    int S2[6] = {11, 13, 15, 17, 19, 20};
    z = Merge(S1,S2);
    printf("%d",z);
    return 0;
}

12、题目略

暴力解：

/*暴力解，设置哈希表来存储数组A中各元素出现的次数，
  再用for循环来比较哈希表中各元素出现的次数，
  最后if判断出现次数最多的次数是否大于n/2*/

/*时间复杂度为O(n)，空间复杂度为O(n)*/

#include <iostream>

using namespace std;

int nums[100] = {0};

int Findzhu(int A[])
{
    int i,maxx = 0, c = 0;
    for(i = 0; i < 6; i++)
    {
        nums[A[i]]++;
    }
    for(i = 0; i < 6; i++)
    {
        if(A[i] > maxx)
            maxx = A[i];
    }
    for(i = 0; i <= maxx; i++)
    {
        if(c < nums[i])
            c = i;
    }
    if(nums[c] > 6/2)
        return c;
    return -1;
}


int main()
{
    int z;
    int A[6] = {1, 9, 9, 9, 9,5};
    z = Findzhu(A);
    printf("%d",z);
    return 0;
}

13、题目略

暴力解：

/*暴力解*/

/*时间复杂度为O(n^2)，空间复杂度为O(n)*/

#include <iostream>

using namespace std;



int FindMissMin(int A[])
{
    int i = 0, j, k = 1;
    while(i < 4)
    {
        if(A[i] < 0)
            i++;
        if(A[i] != k)
            i++;
        else
        {
            i = 0;
            k++;
        }
    }
    return k;
}

int main()
{
    int z;
    int A[4] = {5, -3, 1, 3};
    z = FindMissMin(A);
    printf("%d",z);
    return 0;
}

少暴力一点的解法，先用1和数组元素依次对比，若没有等于1的元素，则返回1，若数组中有1，则把num置0后再用2和数组元素对比..........

int FindMissMin(int A[])
{
    int i, num = 0;
    for(i = 1; ; i++)
    {
        for(int j = 0; j < n; j++)
        {
            if(i == A[j])
                num++;
        }
        if(num == 0)
            return i;  //i就是要找的最小正整数
        else
            num = 0;
     }
}

14、题目略

暴力解（非常暴力）：

/*暴力解*/

/*时间复杂度为O(n^3)，空间复杂度为O(n)*/

#include <iostream>

using namespace std;


void FindminoTrip(int A[], int B[], int C[])
{
    int i, j, k, d;
    int min_d = abs(A[0] - B[0]) + abs(B[0] - C[0]) + abs(C[0] - A[0]);
    for(i = 0; i < 3; i++)
    {
        for(j = 0; j < 4; j++)
        {
            for(k = 0; k < 5; k++)
            {
                d = abs(A[i] - B[j]) + abs(B[j] - C[k]) + abs(C[k] - A[i]);
                if(d < min_d)
                    min_d = d;
            }
        }
    }
    printf("最小距离为%d\n", min_d);
    printf("三元组为：",A[i], B[j], C[k]);
    for(i = 0; i < 3; i++)
    {
        for(j = 0; j < 4; j++)
        {
            for(k = 0; k < 5; k++)
            {
                if(min_d == abs(A[i] - B[j]) + abs(B[j] - C[k]) + abs(C[k] - A[i]))
                    printf("(%d,%d,%d)\n",A[i], B[j], C[k]);
            }
        }
    }
}

int main()
{
    int S1[3] = {-1, 0, 9};
    int S2[4] = {-25, -10, 10, 11};
    int S3[5] = {2, 9, 17, 30, 41};
    FindminoTrip(S1, S2, S3);
    return 0;
}

橙橙疑惑
关注
2018王道数据结构课后习题代码.rar
09-07
2018王道数据结构课后习题代码
【数据结构】王道课后习题（线性表）（一）（可直接运行）
treesorshining的博客
07-07 685
完整题目如下： 显然，只需要遍历找到最小值，并用最后一个元素覆盖即可。 具体实现如下： 1.2 完整代码 2.02 逆置 2.1算法实现 完整题目如下： 要求空间复杂度为O(1)，时间复杂度无要求，那么只需要循环换位即可实现。 代码如下： 2.2 完整代码 3.03 删除所有指定元素 3.1算法实现 完整题目如下： 分析题目，要求时间复杂度O(n)，那么就不能使用最简单的即找即删。可以设定一个变量k用于记录非x的个数，如果该元素不是x，那么就把它放到第k个，同时k+1，这样前k个即全部是非x，再将
2024 王道考研 数据结构+习题讲解_王道课后题pdf
最新发布
2401_86949880的博客
09-03 679
P7【2021版】2.1_线性表的定义和基本操作P8【2021版】2.2.1_顺序表的定义P9【2021版】2.2.2_1_顺序表的插入删除P10【2021版】2.2.2_2_顺序表的查找P11【2021版】2.3.1_单链表的定义P12【2021版】2.3.2_1_单链表的插入删除P13【2021版】2.3.2_2_单链表的查找P14【2021版】2.3.2_3_单链表的建立P15【2021版】2.3.3_双链表P16【2021版】2.3.4_循环链表P17【2021版】2.3.5_静态链表P18【202
数据结构复习—王道课后习题（线性表）
m0_51769031的博客
05-14 2295
一、
数据结构王道课后习题
四块的博客
10-17 1336
第五章 树与二叉树 1.若某非空二叉树的先序序列和后序序列正好相反，则该二叉树的形态是什么？ 二叉树的先序序列为NLR（根左右），后序序列是LRN（左右根）。要使得NLR=LRN（后序序列反序）则成立。L或R应该为空，这样的二叉树每层只有一个节点，即二叉树的形态是其高度等于节点个数。例如： 2.若某非空二叉树的先序序列和后序序列正好相同，则该二叉树的形态是什么？ ...
2021年王道数据结构课后题
killers_999的博客
05-05 3932
使用的顺序表是 https://blog.csdn.net/killers_999/article/details/104418578 这里。 1. 从顺序表中删除具有最小值的元素（假设唯一 ）并由函数返回被删元素的值。 空出的位置由最后一个元素填补， 若顺序表为空则显示出错信息并退出运行。 bool minnum(struct Array *arr,datatype *data){ ...
23王道数据结构代码题全解（二）
漫磋嗟
04-12 3450
此次更新线性表（14/14）计划更新23王道数据结构所有课后代码习题的实现，虽然考试写的一般都是伪代码，但是强迫症的我还是全部实现了一遍，都可以编译运行，包含暴力解和最优解，仓库在这里 https://github.com/mancuoj/wangdao
素素 高中数学人教版必修二第二章 2.2.3 直线与平面平行的性质+2.2.4 平面与平面平行的性质 优质课件.pptx
08-21
素素 高中数学人教版必修二第二章 2.2.3 直线与平面平行的性质+2.2.4 平面与平面平行的性质 优质课件.pptx
2020_2021学年高中数学第二章算法初步2.2.3循环结构课时素养评价含解析北师大版必修3202103041115
08-07
第二道题同样考察了对循环的理解，这里的循环结构用于累加S的值，当i不再满足条件时结束循环。题目中给出了算法框图的运行过程，经过几次迭代后，输出S的值为8。 第三题涉及到的循环结构中，输入a和b的值会影响循环...
高中化学(人教版,选修3)第二章分子结构与性质2.2.3.pdf
10-07
高中化学(人教版,选修3)第二章分子结构与性质2.2.3.pdf
高中数学 第二章 随机变量及其分布 2.2 二项分布及其应用 2.2.3 独立重复试验与二项分布课后训练 2-3.docx
10-23
高中数学的第二章主要探讨随机变量及其分布，其中2.2.3部分涉及独立重复试验与二项分布。二项分布是描述在一系列独立的、结果只有成功或失败的伯努利试验中，成功次数的概率分布。这个概念常用于解决生活中的一些...
王道数据结构的所有选择题
10-29
考研数据结构总结
王道数据结构课后选填汇总
02-19
数据结构复习使用，方便二刷数据结构选填使用
王道数据结构2019考研视频讲解+视频讲义PPT+课后习题讲解
06-10
此资源是配套王道数据结构考研书籍的讲解视频，视频讲义PPT，课后习题讲解（习题讲解不是全部讲解，而是选取一部分题讲解），压缩文档里有视频的百度云链接）
2018王道数据结构课后习题代码
10-26
2018王道数据结构课后习题代码，带非常详细的注释，实现者已考研成功。
王道计算机考研 数据结构 课后编程习题代码（绪论、线性表）
m0_51448653的博客
10-07 530
2.2.3 1. 题意 ：从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删函数的值，空出的位置由最后一个元素填补，若顺序表为空，则显示出错信息并退出运行。 思路 ：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置。 bool Del_Min(SqList &L, ElemType &value) { //删除顺序表L中最小值元素结点，并通过引用型参数value返回其值 //若删除成功，则返回true，否则返回fal
王道数据结构线性表课后习题
lisa丶
05-30 2442
1.1.从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删除的元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行 。bool Del_Min(SqList &amp;L, ElemType &amp;value) { if (L.length == NULL) return false; value = L.data[0]; //假设0号元素的值最小 i...
王道数据结构题目练习
weixin_42705436的博客
11-08 1796
题目 1 从顺序表中删除具有最小值的元素（假设唯一）并由函数返回被删元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。 //删除顺序表中元素值最小的 Status DLMinElem(Sqlist &L,ElemType &value) { //删除顺序表L中最小元素结点，并通过引用型参数value返回其值 if(L.length==0) return false; value=L.data[0]; //假定0号元素是最小的值 int pos=0;
"计算机电路第二章：半导体基本器件和工作原理
计算机电路第二章（“半导体”文档）共40张.pptx 本文总结了计算机电路第二章关于半导体的内容。第二章半导体基本器件介绍了半导体二极管、半导体三极管和MOS场效应管的原理和特性。 2.1 半导体二极管 2.1.1 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值