王道数据结构课后题

已于 2023-10-28 10:07:32 修改
阅读量144 收藏 2
点赞数
文章标签： 数据结构
于 2023-10-26 09:05:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53407125/article/details/134048002
版权

跟着我老婆学的欸嘿嘿嘿嘿  b站搜金可鱼哟

线性表

01

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

算法思想：假设第0 个位置的元素是最小的，设其为min 下标为flag,依次遍历，若有比一个小的元素将其赋值给min

#include <stdio.h>

typedef int ElemType;
#define MaxSize 50
typedef struct SqList
{
    ElemType data[MaxSize] = {2, 3, 4, 6, 7, 1, 8, 9};
    int length = 8;
} SqList;

bool move(SqList &L, int &e)
{
    if (L.length == 0) {
        return false;
    }
    int min = L.data[0];
    int flag = 0;
    for (int i = 1; i < L.length; i++) {
        if (L.data[i] < min) {
            min = L.data[i];
            flag = i;
        }
    }
    e = L.data[flag];
    L.data[flag] = L.data[L.length - 1];
    return true;
}

int main() {
    SqList L;
    printf("original list: ");
    for (int i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");

    int e;
    if (move(L, e)) {
        printf("min value: %d\n", e);
        printf("result list: ");
        for (int i = 0; i < L.length; i++) {
            printf("%d ", L.data[i]);
        }
        printf("\n");
    } else {
        printf("empty list\n");
    }
    return 0;
}

02

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

#include <stdio.h>

#define MaxSize 50
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];
    int length;
} SqList;

void move(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;
    }
}


int main()
{
    SqList L;
    L.length = 6;
    L.data[0] = 1;
    L.data[1] = 2;
    L.data[2] = 3;
    L.data[3] = 6;
    L.data[4] = 5;
    L.data[5] = 4;

    printf("Original Array: ");
    for (int i = 0; i < L.length; i++)
    {
        printf("%d ", L.data[i]);
    }
    printf("\n");

    move(L);

    printf("Reversed Array: ");
    for (int i = 0; i < L.length; i++)
    {
        printf("%d ", L.data[i]);
    }
    printf("\n");

    return 0;
}

03

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

算法思想：设置一个k用来记录，x的个数，例如：本代码中的 第一个1是data[2],k = 1 那么data[3]就往前挪一个位置（删除：将其覆盖）。第二个1是data[5],k = 2 ,data[6]往前挪两个位置

总结规律：a[i-k] = a[i] L.length = n-k

#include <stdio.h>

#define MaxSize 50
typedef int ElemType;
typedef struct
{
    ElemType data[MaxSize] = {5,2,0,1,3,1,4,1,1,4};
    int length = 10;
} SqList;

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

int main()
{
    SqList L;
    ElemType x = 1;

    printf("Original Array: ");
    for (int i = 0; i < L.length; i++)
    {
        printf("%d ", L.data[i]);
    }
    printf("\n");

    Reverse(L, x);

    printf("Modified Array: ");
    for (int i = 0; i < L.length; i++)
    {
        printf("%d ", L.data[i]);
    }
    printf("\n");

    return 0;
}

04

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

#include <stdio.h>

#define MaxSize 50

typedef int ElemType;

typedef struct
{
    ElemType data[MaxSize] = {1, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 9}; // 原有数列数据
    int length; // 原有数列实际长度
} SqList;

/**
 * 删除有序顺序表 *L 中在给定值 s 与 t 之间的所有元素。
 * 删除成功返回 true，否则返回 false。
*/
bool Del(SqList *L, ElemType s, ElemType 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;

    // 寻找第一个大于 t 的元素
    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;
}

int main()
{
    SqList L;
    L.length = 12;

    ElemType s, t;
    printf("Enter the range to delete (elements between s and t will be deleted):\n");
    scanf("%d %d", &s, &t);

    if (Del(&L, s, t))
    {
        printf("The updated sequence list: ");
        for (int i = 0; i < L.length; i++)
            printf("%d ", L.data[i]);
        printf("\n");
    }
    else
    {
        printf("Deletion failed\n");
    }

    return 0;
}

05

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

#include <stdio.h>
#include <stdbool.h>       // 引入stdbool.h头文件用于定义bool类型及相应的true和false值

#define MaxSize 50          // 定义SqList的最大长度
typedef int ElemType;      
typedef struct {
    ElemType data[MaxSize]; // 存储数据的数组
    int length;             // 数组中实际存储的元素个数
} SqList;

bool move(SqList &L, ElemType s, ElemType t)  // 删除SqList中符合某一区间的元素。函数返回值为bool类型，表示是否删除成功。
{
    int k = 0;              // 用于存储满足删除条件的元素的个数，初始值为0。
    if (L.length == 0 || s >= t)
        return false;       // 若SqList长度为0或者s大于等于t，则无法删除，函数返回false。
    for (int i = 0; i < L.length; i++) {     // 遍历SqList中的元素。
        if (L.data[i] >= s && L.data[i] <= t)   // 若当前元素的值在区间内，则需要删除该元素。
            k++;                            // 记录当前需要删除的元素的个数。
        else
            L.data[i - k] = L.data[i];      // 若不需要删除，将当前元素向前移k位（即将需要删除的元素剔除）。
    }
    L.length -= k;          // 更新SqList的长度，即使删除后SqList的长度变为原来的长度k。
    return true;            // 删除成功，函数返回true。
}

int main() {
    SqList L = { {3, 4, 1, 2, 6, 7}, 6 };  // 定义一个SqList并初始化。
    ElemType s, t;

    printf("Initial array: ");
    for (int i = 0; i < L.length; i++) {   // 输出SqList中的初始元素。
        printf("%d ", L.data[i]);
    }
    printf("\n");

    printf("Enter the lower and upper bound of the interval (separated by a space): ");
    scanf("%d %d", &s, &t);         // 读入需要删除的区间。

    if (move(L, s, t)) {            // 若删除成功，输出删除区间后的元素。
        printf("Array after deleting elements in the interval [%d, %d]: ", s, t);
        for (int i = 0; i < L.length; i++) {
            printf("%d ", L.data[i]);
        }
        printf("\n");
    }
    else {                          // 若删除失败，输出相应的信息。
        printf("Unable to delete elements in the interval [%d, %d]\n", s, t);
    }

    return 0;
}

06

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

#include <stdio.h>

#define MaxSize 50
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];
    int length ;
}SqList;

bool move(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;
}

int main() {
    SqList L;

    // 输入数组长度
    printf("Enter the length of the array: ");
    scanf("%d", &L.length);

    // 输入数组元素
    printf("Enter the elements of the array: ");
    for (int i = 0; i < L.length; i++) {
        scanf("%d", &L.data[i]);
    }

    printf("Original array: ");
    for (int i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");

    if (move(L)) {
        printf("Array after removing duplicates: ");
        for (int i = 0; i < L.length; i++) {
            printf("%d ", L.data[i]);
        }
        printf("\n");
    } else {
        printf("Failed to remove duplicates.\n");
    }

    return 0;
}

07

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

#include <stdio.h>

#define MaxSize 50
typedef int ElemType;
typedef struct {
    ElemType data[MaxSize];
    int length;
} SqList;

bool merge(SqList A, SqList B, SqList &C)
{
    if (A.length + B.length > C.length)
        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;
}

int main() {
    SqList A;
    SqList B;
    SqList C;

    // Initialize list A
    A.data[0] = 1;
    A.data[1] = 3;
    A.data[2] = 5;
    A.length = 3;

    // Initialize list B
    B.data[0] = 2;
    B.data[1] = 4;
    B.length = 2;

    // Initialize list C
    C.length = A.length + B.length;

    // Merge lists A and B into C
    if (merge(A, B, C))
    {
        printf("Merge successful. The merged list C is:");
        for (int i = 0; i < C.length; i++)
        {
            printf("%d ", C.data[i]);
        }
        printf("\n");
    }
    else
    {
        printf("Merge failed. The merged list C would exceed the maximum capacity.\n");
    }

    return 0;
}

塔子dhakj
关注
2018王道数据结构课后习题代码.rar
09-07
这个“2018王道数据结构课后习题代码.rar”压缩包则包含了该教材的课后习题解决方案，对于学习者来说，是巩固理论知识和提升编程实践能力的重要资源。 首先，数据结构主要包括数组、链表、栈、队列、树、图等基本...
2018王道数据结构课后习题代码
10-26
2018年王道数据结构课后习题代码是一个针对该课程学习者的重要资源，它包含了对数据结构概念的深入理解和实际编程实践。这份资料的提供者已经通过了考研，这意味着这些代码经过了实际检验，具有一定的权威性和实用性...
2024王道数据结构课后习题代码
m0_51057239的博客
03-14 4661
2.1.2 顺序表初始化（动态） 2.1.3 顺序表上插入和删除 2.2综合题 这些题是王道教材的p18-p19的1-14题，2.2.1即为第一题 2.2.2 2.2.3 未完待续… 2023年四月末之前将更新完本书所有习题
【王道数据结构课后习题代码练习完整版】顺序表
致力于成为一名data scientist 的奋斗者
05-06 1871
设计一个算法，完成用最少时间在表中查找数值为x的元素，若找到，则将其与后继元素位置交换，若找不到，则将其插入表中并使表中元素仍递增有序。,am）和(b1,b2,…2.2.3-3 对长度为n的顺序表L，编写一个时间复杂度为o(n),空间复杂度为o(1)的算法，该算法删除线性表中所有值为x的元素。2.2.3-4 从有序顺序表中删除其值在s与t之间（s
25版王道数据结构课后习题详细分析 第三章栈、队列和数组 3.3栈和队列的应用
2406_86301373的博客
08-12 775
栈的应用不包括 表达式 a*(b+c)-d的后缀表达式是 下面用到了队列 利用栈求表达式的值时，设立运算数栈 OPEN假设 OPEN 只有两个存储单元，则在下 列表达式中，不会发生溢出的是 执行完下列语句段后，i的值为 设有如下递归函数，则计算F(8)需要调用该递归函数的次数为 设有如下递归函数，在func(func(5))的执行过程中，第4个被执行的func函数是 对于一个问题的递归算法求解和其相对应的非递归算法求解， 执行函数时，其局部变量一般采用进行存储 执行操作时，需要使用队列作为辅助存储空间
25版王道数据结构课后习题详细分析 第一章绪论 1.2算法和算法评价
2406_86301373的博客
07-13 986
一个算法应该 A.程序 B.问题求解步骤的描述 C.要满足五个基本特性 D.A和C 某算法的时间复杂度为O(n)，则表示该算法的. 若某算法的空间复杂度为O(1)，则表示该算法。 下列关于时间复杂度的函数中，时间复杂度最小的是。 以下算法的时间复杂度为()。 分析以下各程序段，求出算法的时间复杂度。 统考真题 16.【2022统考真题】下列程序段的时间复杂度是。 int sum=0; for(int i=1;i
25版王道数据结构课后习题详细分析 第一章绪论 1.1数据结构的基本概念
2406_86301373的博客
07-12 714
可以用()定义一个完整的数据结构。 以下数据结构中，()是非线性数据结构。 以下属于逻辑结构的是()。 以下关于数据结构的说法中，正确的是()。 A．数据的逻辑结构独立于其存储结构 B.数据的存储结构独立于其逻辑结构C．数据的逻辑结构唯一决定其存储结构D.数据结构仅由其逻辑结构和存储结构决定 在存储数据时，通常不仅要存储各数据元素的值，而且要存储（)。 对于两种不同的数据结构，逻辑结构或物理结构一定不相同吗? 试举一例，说明对相同的逻辑结构，同一种运算在不同的存储方式下实现时，其运算效 率不同。
2021年王道数据结构课后题
killers_999的博客
05-05 3930
使用的顺序表是 https://blog.csdn.net/killers_999/article/details/104418578 这里。 1. 从顺序表中删除具有最小值的元素（假设唯一 ）并由函数返回被删元素的值。 空出的位置由最后一个元素填补， 若顺序表为空则显示出错信息并退出运行。 bool minnum(struct Array *arr,datatype *data){ ...
24王道数据结构课后综合应用题
aiwxjwxj的博客
07-23 1048
sqlist;i++)I = i;return I;cout << "这是一个空列表" << endl;L.length--;
25版王道数据结构课后习题详细分析 第五章树与二叉树 5.2二叉树的概念
2406_86301373的博客
08-13 848
“二叉树为空”意味着二叉树以下说法中，正确的是 具有10个叶结点的二叉树中有个度为2的结点设高度为h的二叉树上只有度为0和度为2的结点，则此类二叉树中所包含的结点数至少为具有n个结点且高度为n的二叉树的数目为 假设一棵二叉树的结点个数为50,则它的最小高度是设二叉树有2n个结点，且m
考研王道数据结构课后题（代码应用题）
Java程序员十六的博客
07-03 585
并由函数返回被删除元素，空出位置由最后一个元素填补，若顺序表为空，则显示错误信息并推出运行。包含s和t，要求s<t，若s或t不合理或顺序表为空时，显示错误。找到,与后继元素互换;找不到,插入表中并使表仍然有序。要求s<t，若s或t不合理或顺序表为空时，显示错误。如果有环，找出环的入口点并返回；要求时间复杂度为O(n)，空间复杂度为O(1)查找成功输出该节点值，并返回1，否则返回0。要求算法的时间复杂度为O(1)效率高，假设最小值节点唯一。链表为空时，删除表头节点。不使用数组作为辅助空间。
王道数据结构2019考研视频讲解+视频讲义PPT+课后习题讲解
06-10
这个资源包"王道数据结构2019考研视频讲解+视频讲义PPT+课后习题讲解"是针对准备计算机专业考研，特别是北大867科目考生的重要学习资料。 首先，"王道数据结构2019考研视频讲解"部分，可能是由专业讲师录制的一系列...
王道数据结构课后选填汇总
02-19
本汇总主要基于"王道数据结构"教材，旨在为考研复习提供帮助，特别是针对那些正在二刷数据结构的学生。下面将对第二章和第三章的主要知识点进行详尽的解析。 第二章通常涵盖线性结构，特别是数组和链表这两种基本的...
通用型函数——冒泡排序
2401_84654619的博客
10-29 542
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
【数据结构】插入排序和希尔排序
wheeldown的博客
11-01 428
这种方法通过分组和逐步缩小增量的方式，提高了排序效率。综合来看，希尔排序的效率明显高于直接插入排序算法。重复步骤 2-4，直到 gap = 1，此时相当于直接插入排序。当gap > 1时都是预排序，⽬的是让数组更接近于有序。1.元素集合越接近有序，直接插⼊排序算法的时间效率越⾼。的了，这样就会很快。这样整体⽽⾔，可以达到优化的效果。选定一个整数（通常是 gap = n/3 + 1）。将待排序记录分成若干组，每组内记录的距离相等。缩小增量：gap = gap/3 + 1。希尔排序是对直接插⼊排序的优化。
探索数据结构：数组与链表
最新发布
qq_36287830的博客
11-04 420
数组和链表是两种基本但重要的数据结构。选择合适的数据结构对于优化程序性能至关重要。理解它们的特点和适用场景可以帮助开发者做出更好的设计决策。希望本文能为你提供有关数组和链表的清晰认识。
线性数据结构之链表
m0_61840987的博客
10-31 625
单链表、双向链表、循环链表、哨兵链表在不同场景下的应用优势。每种链表类型在特定应用场景中能够发挥其独特的性能优势，通过选择合适的数据结构可以使程序更高效。
三傻排序和对数器
jeffery 的博客
10-31 743
对数器是一种验证算法正确性的方式，可以在没有 OJ 的情况下验证。认识三个简单的排序：插入排序、选择排序、冒泡排序，并用对数器进行验证。
【数据结构与算法】第7课—数据结构之队列
weixin_70620792的博客
10-31 509
只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表栈只允许在栈顶进行插入数据删除数据的操作，称为入栈、出栈（或压栈）队列则是队尾进队头出，满足先进先出的原则，而栈则是后进先出。
王道数据结构课后习题排序
08-18
- *2* *3* [王道数据结构课后题编程（顺序表）](https://blog.csdn.net/RHJlife/article/details/90450834)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值