王道2025数据结构课后题大题代码---顺序表

最新推荐文章于 2024-08-27 22:35:52 发布
最新推荐文章于 2024-08-27 22:35:52 发布
阅读量294 收藏 2
点赞数 4
文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63881564/article/details/139634943
版权

2.2课后题

个人学习所记录笔记，便于复习查看，如有错误，请见谅。

代码均为自己的思路，与标准答案有差异

前半部分为基本的添删改查方法，便于课后题的调用

后半部分为课后题代码

#include <iostream>
#include <map>
#include <cmath>
#include <vector>
#include <algorithm>
using namespace std;

const int  MaxSize =50;
//静态分配
struct SeqList {
    int data[MaxSize];
    int length;
};
//初始化
void InitList(SeqList& L) {
    for (int i = 0; i <MaxSize; i++) {
        L.data[i] = 0;
    }
    L.length = 0; 
}
//插入操作
bool ListInsert(SeqList& L, int i, int e) {
    //如果插入位置不对
    if (i<1 || i>L.length + 1)
        return false;
    //如果数组已满
    if (L.length > MaxSize)
        return false;
    //正常操作
    //先对i后面的数后移
    for (int j = L.length; j >= i; j--) {
        L.data[j] = L.data[j - 1];
    }
    //i是位置，i-1是下标
    L.data[i-1] = e;
    L.length++;
    return true;
}
//删除操作
bool ListDelete(SeqList& L, int i, int &e) {
    //首先判断是否合法
    if (i<1 || i>L.length)
        return false;
    //得到删除的元素
    e =L.data[i - 1] ;
    for (int j = i; j < L.length; j++) {
        L.data[j - 1] = L.data[j];
    }
    L.length--;
    return true;
}

//按位查找
void ListGetELem(SeqList L, int i) {
    cout<< L.data[i - 1]<<endl;
}

//按值查找
void ListLocateElem(SeqList L, int x) {
    bool found = false;
    for (int i = 0; i < L.length; i++) {
        if (L.data[i] == x) {
            cout << "该元素在第" << i + 1 << "位" << endl;
            found = true;
            break;  // 找到了就退出循环
        }
    }
    if (!found) {
        cout << "没有找到元素" << endl;
    }
}


//打印顺序表的元素
void print(SeqList L) {
    cout << "此时表中数据为：" << endl;
    for (int i = 0; i < L.length; i++) {
        cout << L.data[i] << " ";
    }
    cout << endl;
}




// 课后习题
// /// 
//例题1
void test01(SeqList& L) {
    cout << "执行例题1：" << endl;
    if (L.length == 0) {
        cout << "表为空" << endl;
        return;
    }
    //分别用来记录最小值和他的位置
    int mi=L.data[0];
    int idx=0;
    for (int i = 1; i < L.length; i++) {
        if ( L.data[i]<=mi) {
            mi = L.data[i];
            idx = i;
        }
    }
    int e = mi;
    L.data[idx] = L.data[L.length - 1];  
    cout <<" 最小的值为:" << e << endl;
    print(L);
}

//例题2 逆序排列表中数据
void test02(SeqList& L) {
    for (int i = 0, j = L.length - 1; i < j; i++, j--) {
        int temp=L.data[i];
        L.data[i] = L.data[j];
        L.data[j] = temp;
    }
    print(L);
}

//例题3，删除值为x的值
void test03(SeqList& 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之间的所有值
void test04(SeqList& L, int s, int t) {
    int k = 0;
    if(L.length == 0){
        cout << " 顺序表为空"<<endl;
    }
    else if (s > t) {
        cout << " 定值不合理"<<endl;
    }
    else 
    {
        for (int i = 0; i < L.length; i++) {
            int a = L.data[i];
            //不在这个区间
            if (a<s || a>t) {
                L.data[k] = a;
                k++;
            }
        }
        L.length = k;
    }
}

//例题5,删除表中重复元素
void test05(SeqList& L) {
    int k = 0;
    map<int, int> mp;

    for (int i = 0; i < L.length; i++) {
        mp[L.data[i]]++;
    }

    for (auto j : mp) {
        L.data[k] = j.first;
        k++;
    }
    L.length = k;
}

//例题6 ，将两个有序顺序表合成一个
// 这个算法很典型，需要牢固掌握
void test06(SeqList& A, SeqList& B, SeqList& C) {
    
    InitList(A);
    //此时a表中数据为1 3 5 7
    ListInsert(A, 1, 1);

    ListInsert(A, 2, 3);

    ListInsert(A, 3, 5);

    ListInsert(A, 4, 7);

   
    InitList(B);
    //此时b表中数据为2 4 6
    ListInsert(B, 1, 2);

    ListInsert(B, 2, 4);

    ListInsert(B, 3, 6);

    //将其合并到c表中，结果应该为1 2 3 4 5 6 7
    InitList(C);
    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++];
        }
    }

    // 将剩余元素添加到结果顺序表 C
    while (i < A.length) {
        C.data[k++] = A.data[i++];
    }
    while (j < B.length) {
        C.data[k++] = B.data[j++];
    }

    C.length = k; // 更新结果顺序表 C 的长度
    cout << "a中数据为" << endl;
    print(A);
    cout << "b中数据为" << endl;
    print(B);
    cout << "c中数据为" << endl;
    print(C);
}

//例题7，实际上就是数组部分反转
//可以利用vector数组的reverse方法
void test07() {
    // 前部分长度为3，后面为4
    vector<int> a = { 1, 2, 3, 4, 5, 6, 7 };

    // 将前部分反转
    reverse(a.begin(), a.begin() + 3);  // 3 2 1 4 5 6 7

    // 将后部分反转
    reverse(a.begin() + 3, a.end());    // 3 2 1 7 6 5 4

    // 将整个数组反转
    reverse(a.begin(), a.end());        // 4 5 6 7 1 2 3

    // 输出结果以验证
    for (int num : a) {
        cout << num << " ";
    }
    cout << endl;
}

//例题8 查找数据，找到交换相邻位置，找不到插入最后
//这段代码也能完成，但是不是最快的
void test08(SeqList& L, int x) {
    int i;
    bool flag = 0;
    //如果找到了
    for (i = 0; i < L.length; i++) {
        if (L.data[i] == x) {
            if (i < L.length - 1) {
                int temp = L.data[i];
                L.data[i] = L.data[i + 1];
                L.data[i + 1] = temp;
                flag = 1;
            }
            break;
        }
        else if (L.data[i] > x) {
            break;
        }
    }
    //如果没有找到
    if (flag == 0) {
        if (i == L.length || L.data[i] > x) {
            // 插入元素
            if (L.length >= MaxSize) {
                cout << "顺序表已满，无法插入元素" << endl;
                return;
            }
            for (int j = L.length; j > i; j--) {
                L.data[j] = L.data[j - 1];
            }
            L.data[i] = x;
            L.length++;
        }
    }
}
 
//例题9  输出三个数组中相同的元素
//另一种做法，遍历三个数组中的数据到map函数中，输出map中值为3的数据，但是该方法时间复杂度较高
void test09(int n) {
    int a[] = { 1,2,3 };
    int b[] = { 2,3,4 };
    int c[] = { 2,4,6 };

    int i=0, j=0, k=0;//指针
    //n代表着判断次数，即最短的数组的长度？？
    while (i < n && j < n && k < n) {
        //如果三个数组元素相同
        if (a[i] == b[j] && b[j] == c[k]) {
            cout << a[i] << endl;
            i++;
            j++;
            k++;
        }
        //如果不相同
        //最大的数据所指向的下标不动，其他的自增
        int ma = max(max(a[i], b[i]), c[i]);
        if (a[i] < ma) i++;
        if (b[i] < ma) j++;
        if (c[i] < ma) k++;

    }
}

//例题10 循环左移
//时间和空间复杂度均为on，也可采用例题7的方法，空间复杂度变为o1
void test10() {
    vector<int> a = { 1, 2, 3, 4, 5 };
    cout << "输入左移次数" << endl;
    int p; cin >> p;

    // 求出数组a的长度
    int len = a.size();

    // 元素移动次数
    int pp = p % len;

    vector<int> b(len);
    for (int i = 0; i < len; i++) {
        // 计算新位置，并确保索引为正数
        int newPos = (i + len - pp) % len;
        b[newPos] = a[i];
    }

    for (int i = 0; i < len; i++) {
        cout << b[i] << " ";
    }
    cout << endl; // 别忘了在输出完后换行
}

//例题11 求两个数列的中位数
//思路：可以把两个数列合成一个，然后求中位数
//也可以用指针依次遍历判断，类似例题9，
void test11() {
    //采用思路2
    vector<int> a = { 11, 13, 15, 17, 19 };
    vector<int> b = { 2, 4, 6, 8, 20, 21 };

    double len1 = a.size();
    double len2 = b.size();
    //向上取整
    int len = ceil((len1 + len2) / 2.0); // 确保使用浮点数计算

    int i = 0, j = 0, k = 0;
    int mi = 0;

    while (k < len) {
        //防止越界或者一个数组遍历完成
        if (i < a.size() && (j >= b.size() || a[i] < b[j])) {
            mi = a[i];
            i++;
        }
        else {
            mi = b[j];
            j++;
        }
        k++;
    }

    cout << mi << endl;
}

//例题12 求主元素（数组中数据最多的元素且数量大于一半）
void test12() {
    vector<int> a = { 0,5,5,3,5,7,5,5 };
    map<int, int> mp;

    for (int i = 0; i < a.size(); i++) {
        mp[a[i]]++;
    }
    int n = a.size();

    int ma = 0;
    int maxnum = -1;
    for (auto j : mp) {
        if (j.second > ma) {
            ma = j.second;
            maxnum = j.first;
        }
    }
   
    if (ma > n / 2) {
        //输出ma所对应的那个元素
        for (auto j : mp) {
            if (j.second == ma)
                cout << j.first;
        }
    }
    else {
        cout << -1;
    }
}

//例题13 找出数组中未出现的最小正整数
void test13() {
    vector<int> a = { -5,0,2,3 };

    bool vis[100] = { 0 };
    for (int i = 0; i < a.size(); i++) {
        if (a[i] >= 0) {
            vis[a[i]] = 1;
        }
    }
    for (int i = 0; i < a.size(); i++) {
        int temp = i;
        if (vis[i] == 0) {
            cout << temp << endl;
            break;
        }
    }
}

//例题14
void test14() {
    vector<int> arr1 = { -1, 0, 9 };
    vector<int> arr2 = { -25, -10, 10, 11 };
    vector<int> arr3 = { 2, 9, 17, 30, 41 };

    sort(arr1.begin(), arr1.end());
    sort(arr2.begin(), arr2.end());
    sort(arr3.begin(), arr3.end());

    int i = 0, j = 0, k = 0;
    //最小的值
    int min_dist = INT_MAX;
    //通过指针对三个数组数据进行遍历
    while (i < arr1.size() && j < arr2.size() && k < arr3.size()) {
        int dist = abs(arr1[i] - arr2[j]) + abs(arr2[j] - arr3[k]) + abs(arr3[k] - arr1[i]);

        if (dist < min_dist) {
            min_dist = dist;
        }

        //将指针（或索引）移动到三个数组中最小元素的位置
        if (arr1[i] <= arr2[j] && arr1[i] <= arr3[k]) {
            i++;
        }
        else if (arr2[j] <= arr1[i] && arr2[j] <= arr3[k]) {
            j++;
        }
        else {
            k++;
        }
    }

    cout << "最短距离为：" << min_dist << endl;
}
int main() {
    SeqList A;
    SeqList B;
    SeqList C;
    SeqList L;
    InitList(L);

    ListInsert(L, 1, 1);

    ListInsert(L, 2, 2);

    ListInsert(L, 3, 3);

    ListInsert(L, 4, 4);

    ListInsert(L, 5, 5);
    print(L);
    cout << "------" << endl;


    //test06(A, B, C);
    //test08(L,6);
    //test04(L,1,3);
    //print(L);
    
    test14();
    return 0;
}

瑞香华
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【2025王道数据结构】王道数据结构课后代码题汇总答案C、C++代码实现完整版大全（可直接运行）
CSDN 精品推荐
04-25 1万+
下面内容是本人在复习王道数据结构的过程中, 对一些算法设计题目的全部实现（答案解析全部都是伪码或者函数的部分实现，不可调试运行），不一定是最优的, 但是都能保证端到端测试运行，本文会陆陆续续更新，个人水平有限，可能文章里面存在一些问题，还望各位多多指点。   加油，阿光！！！我看好你哦😋😋😋 以下摘自王道2023年数据结构考研复习指导题目 文章目录 😉第2章：线性表 ✌18页综合应用题 题号 题解链接 1 传送门 2 传送门 3 传送门 4 传送门 5 传送.
19版考研数据结构王道课后习题代码-图【未完】
努力努力再努力0.0的博客
09-18 435
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
2025王道数据结构19页第二大题06
m0_63787898的博客
03-29 121
这道题可以借助两个“指示顺序表位置的指针进行比较”(实际上是下标),i指向表L1的最小的那个数,j指向表L2的最小的那个数,如果i指的数小于等于j指向的数,把L1的数放入L3,并且i指针后移;否则把L1的数放入L3,并且j指针后移。
王道应用题整理
m0_47776000的博客
08-23 1881
王道应用题二、线性表(2.1) 顺序表2.1.1 顺序表查找最小值并返回被删元素的值/*搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置。*/boolDel_Min(sqList &L,int&value){ if(L.length ==0) returnfalse; value = L.data[0]; intpos = 0; for(inti=1;i
2018王道数据结构课后习题代码.rar
09-07
2018王道数据结构课后习题代码
王道数据结构习题代码2.2.3(线性表)
weixin_46503238的博客
04-24 962
第一题(c语言) #include <stdio.h> #include <stdlib.h> #include<stdbool.h> #define maxn 100 typedef int Elemtype; typedef struct { Elemtype data[maxn]; int len; } SqList; bool Del_Min(SqList *L,Elemtype *e) { if(L->len==0)
考研数据结构——链表相关大题（含解析和代码超详细）
给你糖ya的博客
04-01 1058
1.链表题常用方法有：头插法、尾插法、逆置法、归并法、双指针法等。2.对于顺序表，因为可以直接存取，所以经常结合排序和查找的几种算法设计思路进行设计，如归并排序、二分查找等。3.对于算法设计题，若能写出数据结构类型的定义、正确的算法思想，则至少给一半的分数；若能用伪代码写出自然更好；比较复杂的地方可以直接用文字表达。4.本章节（包括顺序表的内容，即下面这个链接）的所有习题要二刷三刷，一定要掌握！！！考研数据结构——线性表相关大题（含解析和代码）_数据结构考研真题线性表-CSDN博客。
2021王道数据结构课后大题代码全部实现.zip
06-17
数据结构是计算机科学中的核心课程，它探讨了如何在计算机...2021王道数据结构课后大题代码实现的资源为学习者提供了一个宝贵的实践平台，通过这些实例，可以更深入地理解数据结构的本质，从而更好地运用到实际项目中。
2018王道数据结构课后习题代码
10-26
2018年王道数据结构课后习题代码是一个针对该课程学习者的重要资源，它包含了对数据结构概念的深入理解和实际编程实践。这份资料的提供者已经通过了考研，这意味着这些代码经过了实际检验，具有一定的权威性和实用性...
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
王道数据结构2025顺序表课后题5，6
qq_59095655的博客
03-26 478
5.有序顺序表中删除所有值重复的元素，使元素值均不同。6.两个有序表合成一个新的有序表。
2021版王道数据结构课后代码题全部实现
Otto的学习笔记
03-16 9148
历时3个多月，把21版王道数据结构的课后代码题全部实现了一遍，一共96道题 文件目录结构： 编程环境：Visual Studio 2019 编程语言：C/C++ 其中，每道题都是一个独立的cpp文件，可以独立运行。在树和图的章节，会有输入样例和对应的示例图。 cpp文件结构 建立要求的数据结构 题目说明 题目要求的代码 运行示例 以树章节的题目示例： #include <iostream> #include <stack> #include <queue>
19版考研数据结构王道课后习题代码-查找【完】
努力努力再努力0.0的博客
09-17 442
#include <iostream> #include <stdio.h> #include <cstdio> #include <string> #include <string.h> #include <math.h> #include <algorithm> #include <stack> ...
王道数据结构课后题编程（顺序表）
任萌新的小生活
05-22 2053
以下问题都简述! 1.搜索顺序表，查找最小值元素，用最后的元素代替它。 思想：初始为第一个元素为最小值，遍历第2-n个元素，寻找最小值，并记录位置，遍历完成后替换。（为空则退出） bool delete_min(SqList &L) { int i; int Min,pos; if(L.length==0) return false; ...
王道代码题汇总（持续更新）
m0_49218627的博客
06-28 1490
主要用于复习
数据结构——顺序表
m0_61965705的博客
08-27 496
例如：查找顺序表中的某个元素所在下标，就可以使用ForeachSeqList函数，搭配FindData函数传参对遍历到的数据进行操作。如果要存放字符串类型的，最好写成以下形式。空间可以不连续，访问元素方便。
Java-数据结构-包装类和认识泛型 !!!∑(ﾟДﾟノ)ノ
最新发布
2303_80388948的博客
08-27 1158
对于泛型就是：使用与许多许多类型。从代码上来说呢，就是对类型实现了参数化。对于引出泛型，我们来实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。在这里呢，我们用 Object类 来进行创建数组，Object是所有类的父类，但是呢，我们在这里呢就有一些问题，我们来看看：1、在这里呢，我们这个数组当中可以存放任何类型2、我们每次进行的到值时候呢，都要进行强转。
数据结构—链表
2301_79909332的博客
08-27 730
数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。数据量增长与程序所占用空间的比例关系称为空间复杂度。顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列 、树 二叉树。使用该函数遍历顺序表内元素，符合条件的可对其进行计数和打印。使用该函数遍历顺序表内元素，符合条件的对其进行修改。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。1.空间可以不连续，访问元素不方便。3.程序 = 数据结构 + 算法。4.链表的插入和删除效率很高。
"王道数据结构：线性表顺序表综合应用题1-高效删除元素算法
以上是王道数据结构-线性表中顺序表的一些综合应用题的题目描述。这些题目都要求设计算法，满足特定的时间复杂度和空间复杂度，并且要求对顺序表进行特定的操作。 在第一道题中，要求设计一个时间复杂度为 O(n)，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值