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

已于 2022-11-28 23:28:28 修改
阅读量2.5k 收藏 25
点赞数 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;
}

橙橙疑惑
关注
  • 5
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
王道数据结构考研复习指导（2022年）-选择题(CSDN).pdf
12-28
王道数据结构考研复习指导（2022年）-选择题汇总，手动录入+清晰版
【王道数据结构课后习题代码练习完整版】链表
致力于成为一名data scientist 的奋斗者
05-06 794
每当在链表中进行过一次Locate(L,x)运算时，令元素值为x的结点中freq的值增加1，并使此链表中结点保持访问频度非增（递减）的顺序排列，同时最近访问的结点排在频度相同的结点前面，以便使频繁访问的结点总是靠近表头。,an}，B={bn,…2.3.7-19 设有一个带头结点的循环单链表，其结点值均为正整数，设计一个算法，反复找出单链表中结点值最小的结点并输出，然后将该结点删除，直到单链表为空为止，再删除表头结点。2.3.7-2 在带头结点的单链表L中，删除所有值为x的结点，并释放其空间。
王道数据结构课后代码题p40 17.设计一个算法用于判断带头结点的循环双链表是否对称（c语言代码实现）
最新发布
m0_46702681的博客
09-26 2297
与普通双链表相比，循环双链表的特点是最后一个节点的 next 指针指向第一个节点，第一个节点的 prior指针指向最后一个节点，这样就构成了一个环形结构。循环双链表是一种链表数据结构，在链表的基础上增加了头尾相连的循环特性，即链表的最后一个节点指向第一个节点，同时每个节点除了储存下一个节点的指针外还储存前一个节点的指针，这样可以实现在链表两端快速插入和删除元素的操作。让p从左向右扫描，q从右向左扫描，直到他们指向同一结点或相邻结点为止，若他们值相同，则继续进行下去，否则返回0。=p是判断结点个数为偶数。
2021年王道数据结构课后题
killers_999的博客
05-05 3811
使用的顺序表是 https://blog.csdn.net/killers_999/article/details/104418578 这里。 1. 从顺序表中删除具有最小值的元素（假设唯一 ）并由函数返回被删元素的值。 空出的位置由最后一个元素填补， 若顺序表为空则显示出错信息并退出运行。 bool minnum(struct Array *arr,datatype *data){ ...
22王道数据结构2.3.7算法题
qq_50679120的博客
04-02 792
1、设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点。 非递归常规解（带头结点）： //删除所有值为x的结点（带头结点） void Del_X_3(LinkList &L) { int x; LNode *p = L->next; //p用来遍历单链表 LNode *q; //q用来暂时替代p，然后将结点free LNode * pre = L; printf("请输入删除重复值："); scanf(
【2025王道数据结构】王道数据结构课后代码题汇总答案C、C++代码实现完整版大全（可直接运行）
CSDN 精品推荐
04-25 1万+
下面内容是本人在复习王道数据结构的过程中, 对一些算法设计题目的全部实现（答案解析全部都是伪码或者函数的部分实现，不可调试运行），不一定是最优的, 但是都能保证端到端测试运行，本文会陆陆续续更新，个人水平有限，可能文章里面存在一些问题，还望各位多多指点。   加油，阿光！！！我看好你哦😋😋😋 以下摘自王道2023年数据结构考研复习指导题目 文章目录 😉第2章：线性表 ✌18页综合应用题 题号 题解链接 1 传送门 2 传送门 3 传送门 4 传送门 5 传送.
王道数据结构精选习题及解析
weixin_43757333的博客
03-25 2144
而为了记录最小值结点的前置结点，我们还需要一个结点，专门作为当前工作结点的前一个结点，工作结点后移一步的过程中，要保持该前置结点是工作结点的前一个结点。链表有一个头结点，我们初始化时也为其保留一个结点，也就是图上的a1，然后我们依次遍历a2及其后面的结点，将其在合适的位置插入。由于我们没有新建一个链表，而是在原来的l1的基础上去改箭头，所以我们需要一个多的指针去存储l1当前工作指针的下一个指针。还有就是最后一步，循环完毕时，最后一个结点是没有指向前一个结点的，因此不能忘记这一步操作！
计算机考研王道408【数据结构/计算机组成原理/操作系统/计算机网络】知识点总结（PDF版）
qq_36823550的博客
07-30 1万+
这些资料是我2021年上岸时所总结的，主要分为2部分。 第一部分是文件结尾带**全书考点**的，是我参考王道当年的视频PPT以及书本的章节，捋出来的，基本涉及王道书本的每个知识点（当然新增加或者删减的知识点是没有的），由于当时数据结构学的比较彻底，所以当时没有按照视频做数据结构的全书考点总结。 第二部分是文件结尾带**难点总结**的，是在我刷完王道课本课后题以及做了一部分往年408的真题后，查缺补漏总结出来的，包含一些比较常考或者比较难记的**知识点**和**公式**。...
2021版王道数据结构课后代码题全部实现
Otto的学习笔记
03-16 8872
历时3个多月，把21版王道数据结构的课后代码题全部实现了一遍，一共96道题 文件目录结构： 编程环境：Visual Studio 2019 编程语言：C/C++ 其中，每道题都是一个独立的cpp文件，可以独立运行。在树和图的章节，会有输入样例和对应的示例图。 cpp文件结构 建立要求的数据结构 题目说明 题目要求的代码 运行示例 以树章节的题目示例： #include <iostream> #include <stack> #include <queue>
2021 王道考研 数据结构+习题讲解
热门推荐
weixin_47312141的博客
10-03 4万+
2021 王道考研 数据结构 P1【2021版】0.0 课程指南 P2【2021版】1.1.0 开篇_数据结构在学什么 P3【2021版】1.1.1 数据结构的基本概念 P4【2021版】1.2.1 算法的基本概念 P5【2021版】1.2.2 算法的时间复杂度 P6【2021版】1.2.3 算法的空间复杂度 P7【2021版】2.1_线性表的定义和基本操作 P8【2021版】2.2.1_顺序表的定义 P9【2021版】2.2.2_1_顺序表的插入删除 P10【2021版】2.2.2_2_顺序表的查找 P1
王道操作系统课后题选填.doc
02-19
总结王道操作系统课后练习题，方便二刷课后选填
考研-数据结构-殷人昆.zip
09-09
1.1 针对考研数据结构的代码书写规范以及C 与C 语言基础1 1.1.1 考研综合应用题中算法设计部分的代码书写规范1 1.1.2 考研中的C 与C 语言基础3 1.2 算法的时间复杂度与空间复杂度分析基础 12 1.2.1 考研中的算法时间...
【优化方案】2020高中数学 第二章2.2.3第二课时课时活页训练 苏教版必修5.doc
10-12
【优化方案】2020高中数学 第二章2.2.3第二课时课时活页训练 苏教版必修5.doc
【优化方案】2020高中数学 第二章2.2.3第一课时课时活页训练 苏教版必修5.doc
10-12
【优化方案】2020高中数学 第二章2.2.3第一课时课时活页训练 苏教版必修5.doc
【优化方案】2020高中数学 第二章2.2.3第一课时随堂即时巩固 苏教版必修5.doc
10-12
【优化方案】2020高中数学 第二章2.2.3第一课时随堂即时巩固 苏教版必修5.doc
高中化学(人教版,选修3)第二章分子结构与性质2.2.3.pdf
10-07
高中化学(人教版,选修3)第二章分子结构与性质2.2.3.pdf
【王道数据结构课后习题代码练习完整版】顺序表
致力于成为一名data scientist 的奋斗者
05-06 1085
设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置交换，若找不到，则将其插入表中并使表中元素仍递增有序。,am）和(b1,b2,…2.2.3-3 对长度为n的顺序表L，编写一个时间复杂度为o(n),空间复杂度为o(1)的算法，该算法删除线性表中所有值为x的元素。2.2.3-4 从有序顺序表中删除其值在s与t之间（s
2024王道数据结构课后习题代码
m0_51057239的博客
03-14 3969
2.1.2 顺序表初始化（动态） 2.1.3 顺序表上插入和删除 2.2综合题 这些题是王道教材的p18-p19的1-14题，2.2.1即为第一题 2.2.2 2.2.3 未完待续… 2023年四月末之前将更新完本书所有习题
王道数据结构——第二章顺序表算法题
m0_48892299的博客
05-09 1443
第二章 表 顺序表算法题 1. 寻找最小元素返回其值并删除，同时该位置由最后一个元素补充 思路：遍历整个顺序表，记录下最小值的位置，将其删除。 bool Del_Min(Sqlist &L,int &e){ //判空 if(L.length == 0){ return false; } int pos = 0; for(int i = 0；i<L.length;i++){ if(L.data[pos]>L.d
form-render2.2.3版本 drawerList 的属性是自定义组件，如何保存数据
06-10
对于 form-render2.2.3 版本中的 drawerList 属性，如果是一个自定义组件，那么保存数据的方法取决于该组件的具体实现。一般来说，自定义组件需要通过 props 接受传入的数据，并在组件内部进行处理和保存。具体的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值