山东理工大学 顺序表练习题答案

最新推荐文章于 2024-01-18 18:02:40 发布
最新推荐文章于 2024-01-18 18:02:40 发布
阅读量1.2k 收藏 4
点赞数
分类专栏： 小组成员 练习题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34952846/article/details/52612332
版权

使用需明白，我提供的代码并不是给大家抄的，而是给大家一个思路来做题。如果你一开始就会意错了的话（只会抄的话），你的水平永远不会得到大的飞跃，如果你还对自己有严格的要求的话，就可以略微参考一下。代码有什么不好或不对的地方欢迎提出。有什么不懂的地方可以尽可能的提出来，我会做解答。可以当面叫我解答（提供给我小组的成员）。(天啊！说的好官方啊！快被自己唬住了！)


顺序表应用1：多余元素删除之移位算法

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <algorithm>
using namespace std;

const int MAX = 10005;
typedef struct
{
    int *elem;
    int length;
}Sq;

void inti(Sq *L, int m)
{
    L->elem = (int *)malloc(MAX*4); //int类型代表的是4个字节，这里也可以写成sizeof(int)
    if ( !L->elem )
        exit(-1);                   //如果空间不足,这一步可以删除
    L->length = m;
}

void create(Sq *L, int m)
{
    int i;
    for ( i = 0;i < m; i++ )
    {
        scanf ( "%d", &L->elem[i] );
    }
}

void del(Sq *L,int m)
{
    int *p;
    for ( p = &L->elem[m]; p < L->elem + L->length-1 ; p++ )
    {
        *p = *(p+1);
    }
    L->length--;
}

void ioc(Sq *L)
{
    int *p, *q;                     //建立两个指针
    q = L->elem;                    //让q指针指向第一个L串的位置坐标

    while ( q != L->elem+L->length )        //当q为L串中的最后一个元素时退出
    {
        p = q+1;                    //p指针代表的永远是q的前面的元素
        while ( p != L->elem+L->length )
        {
            if ( *p == *q )
            {
                del (L, (p-L->elem));   //(p-L->elem)代表的是一个数，相当于L串中的数组下标，以便准确找到该元素
                p--;                   //p在该时刻往前进了一个格这里需减去
            }
            p++;                       //千万不要忘了++
        }
        q++;
    }
}

void display(Sq *L)
{
    int i;
    for ( i = 0;i < L->length; i++ )
    {
        printf (i != L->length-1 ? "%d " : "%d\n", L->elem[i]);
    }
}

int main()
{
    int n, m;
    Sq L;
    scanf ( "%d", &n );
    while ( n-- )
    {
        scanf ( "%d", &m );
        inti(&L, m);
        create(&L, m);
        ioc(&L);
        display(&L);
    }
    return 0;
}

顺序表应用2：多余元素删除之建表算法 

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

const int MAX = 10005;
typedef struct
{
    int *elem;
    int length;
}Sq;

void inti(Sq *L)
{
    L->elem = (int *)malloc(MAX*4);
    if ( !L->elem )
        exit(-1);
    L->length = 1;
}

void create(Sq *L, int m)
{
    int i;
    for ( i = 0;i < m; i++ )
    {
        scanf ( "%d", &L->elem[i] );
    }
}

void del(Sq *L, int h)
{
    L->elem[L->length] = L->elem[h];
    L->length++;
}

void ioc(Sq *L, int m)
{
    int *p, *q;
    p = L->elem+1;
    while ( p < L->elem+m )
    {
        q = L->elem;
        int ok = 1;
        while ( q < p )
        {
            if ( *q == *p )
            {
                ok = 0;
                break;
            }
            q++;
        }
        if ( ok )
        {
            del(L, (p-L->elem));
        }
        p++;
    }
}

void display(Sq *L)
{
    int i;
    for(i = 0;i < L->length; i++)
    {
        printf(i != L->length-1 ? "%d " : "%d\n", L->elem[i]);
    }
}

int main()
{
    int n, m;
    Sq L;
    scanf ( "%d", &n );
    while ( n-- )
    {
        scanf ( "%d", &m );
        inti(&L);
        create(&L, m);
        ioc(&L, m);
        display(&L);
    }
    return 0;
}


顺序表应用3：元素位置互换之移位算法 

#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <iostream>
using namespace std;

const int MAX = 1000005;
typedef struct
{
    int *elem;
    int length;
}Sq;

void inti(Sq *L, int n)
{
    L->elem = (int *)malloc(4*MAX);
    if ( !L->elem )
        exit(-1);
    L->length = n;
}

void create(Sq *L, int n)
{
    int i;
    for ( i = 0;i < n; i++ )
    {
        scanf ( "%d", &L->elem[i] );
    }
}

void ioc(Sq *L,int n, int m)
{
    int i, j, temp;
    for ( i = 0;i < m; i++ )
    {
        temp = L->elem[0];
        for ( j = 1;j < n; j++ )
        {
            L->elem[j-1] = L->elem[j];
        }
        L->elem[n-1] = temp;
    }
}

void display(Sq *L)
{
    int i;
    for ( i = 0;i < L->length; i++ )
    {
        printf ( i == L->length-1 ? "%d\n" : "%d ", L->elem[i] );
    }
}

int main()
{
    int T;
    int n, m;
    Sq L;
    scanf ( "%d", &T );
    while ( T-- )
    {
        scanf ( "%d %d", &n, &m );
        inti(&L, n);
        create(&L, n);
        ioc(&L, n, m);
        display(&L);
    }
    return 0;
}



顺序表应用4：元素位置互换之逆置算法 

#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <iostream>
using namespace std;

const int MAX = 1000005;
typedef struct
{
    int *elem;
    int length;
}Sq;

void inti(Sq *L, int n)
{
    L->elem = (int *)malloc(4*MAX);
    if ( !L->elem )
        exit(-1);
    L->length = n;
}

void create(Sq *L, int n)
{
    int i;
    for ( i = 0;i < n; i++ )
    {
        scanf ( "%d", &L->elem[i] );
    }
}

void rever(Sq *L, int be, int en)
{
    int i;
    int num = (en-be+1)/2;
    for ( i = 0;i < num; i++ )
    {
        int temp = L->elem[be];
        L->elem[be] = L->elem[en];
        L->elem[en] = temp;
        be++;
        en--;
    }
}

void ioc(Sq *L,int n, int m)
{
    rever(L, 0, m-1);
    rever(L, m, n-1);
    rever(L, 0, n-1);
}

void display(Sq *L)
{
    int i;
    for ( i = 0;i < L->length; i++ )
    {
        printf ( i == L->length-1 ? "%d\n" : "%d ", L->elem[i] );
    }
}

int main()
{
    int T;
    int n, m;
    Sq L;
    scanf ( "%d", &T );
    while ( T-- )
    {
        scanf ( "%d %d", &n, &m );
        inti(&L, n);
        create(&L, n);
        ioc(&L, n, m);
        display(&L);
    }
    return 0;
}



顺序表应用5：有序顺序表归并 

#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <iostream>
using namespace std;

const int MAX = 10005;
typedef struct
{
    int *elem;
    int length;
}Sq;

void inti(Sq *L, Sq *M, Sq *S, int n, int m)
{
    L->elem = (int *)malloc(4*MAX);
    M->elem = (int *)malloc(4*MAX);
    S->elem = (int *)malloc(2*4*MAX);
    L->length = n;
    M->length = m;
    S->length = n+m;
}

void create(Sq *L, Sq *M, int n, int m)
{
    int i;
    for ( i = 0;i < n; i++ )
    {
        scanf ( "%d", &L->elem[i] );
    }
    L->elem[i] = (1 << 30);
    for ( i = 0;i < m; i++ )
    {
        scanf ( "%d", &M->elem[i] );
    }
    M->elem[i] = (1 << 30);
}

void ioc(Sq *L, Sq *M, Sq *S, int n, int m)
{
    int i, j, k;
    i = j = 0;
    for ( k = 0;k < S->length; k++ )
    {
        if(L->elem[i] < M->elem[j])
        {
            S->elem[k] = L->elem[i];
            i++;
        }
        else
        {
            S->elem[k] = M->elem[j];
            j++;
        }
    }
}

void display(Sq *S)
{
    int i;
    for ( i = 0;i < S->length; i++ )
    {
        printf ( i == S->length-1 ? "%d\n" : "%d ", S->elem[i] );
    }
}

int main()
{
    int n, m;
    Sq L, M, S;
    scanf ( "%d %d", &n, &m );
    inti(&L, &M, &S , n, m);
    create(&L, &M , n, m);
    ioc(&L, &M, &S , n, m);
    display(&S);
    return 0;
}



顺序表应用6：有序顺序表查询 

#include <algorithm>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

const int MAX = 10005;
typedef struct
{
    int *elen;
    int length;
}Sq;

void create(Sq *L, int m)
{
    int i;
    L->elen = (int *)malloc(MAX*4);
    for( i = 0;i < m; i++ )
    {
        scanf ( "%d", &L->elen[i] );
    }
    L->length = m;
}

int locList(Sq *L, int num)
{
    int left = 0;
    int right = L->length-1;
    while(left <= right)
    {
        int mid = (right+left)/2;
        if(L->elen[mid] == num)
        {
            return mid+1;
        }
        else if(L->elen[mid] < num)
        {
            left = mid+1;
        }
        else if(L->elen[mid] > num)
        {
            right = mid-1;
        }
    }
    return -1;
}

int main()
{
    Sq L;
    int n,m,i,h;
    scanf("%d",&n);
    create(&L, n);
    scanf("%d",&m);
    for(i = 0;i < m; i++)
    {
        scanf ( "%d", &h );
        int flag = locList(&L,h);
        if ( flag == -1 )
            printf ( "No Found!\n" );
        else
            printf ( "%d\n", flag );
    }
    return 0;
}



顺序表应用4-2：元素位置互换之逆置算法(数据改进） 

#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <iostream>
using namespace std;

const int MAX = 1000005;
typedef struct
{
    int *elem;
    int length;
}Sq;

void inti(Sq *L, int n)
{
    L->elem = (int *)malloc(4*MAX);
    if ( !L->elem )
        exit(-1);
    L->length = n;
}

void create(Sq *L, int n)
{
    int i;
    for ( i = 0;i < n; i++ )
    {
        scanf ( "%d", &L->elem[i] );
    }
}

void rever(Sq *L, int be, int en)
{
    int i;
    int num = (en-be+1)/2;
    for ( i = 0;i < num; i++ )
    {
        int temp = L->elem[be];
        L->elem[be] = L->elem[en];
        L->elem[en] = temp;
        be++;
        en--;
    }
}

void ioc(Sq *L,int n, int m)
{
    rever(L, 0, m-1);
    rever(L, m, n-1);
    rever(L, 0, n-1);
}

void display(Sq *L)
{
    int i;
    for ( i = 0;i < L->length; i++ )
    {
        printf ( i == L->length-1 ? "%d\n" : "%d ", L->elem[i] );
    }
}

int main()
{
    int T;
    int n, m;
    Sq L;
    scanf ( "%d", &n );
    inti(&L, n);
    create(&L, n);
    scanf ( "%d", &T );
    while ( T-- )
    {
        scanf ( "%d", &m );
        ioc(&L, n, m);
        display(&L);
    }
    return 0;
}



顺序表应用7：最大子段和之分治递归法

#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <iostream>
using namespace std;

const int MAX = 50005;
typedef struct
{
    int *elem;
    int length;
}Sq;
int ant, max1;

void inti(Sq *L, int n)
{
    L->elem = (int *)malloc(4*MAX);
    if ( !L->elem )
        exit(-1);
    L->length = n;
}

void create(Sq *L, int n)
{
    int i;
    for ( i = 0;i < n; i++ )
    {
        scanf ( "%d", &L->elem[i] );
    }
}

void comput(Sq *L, int be, int mid, int en)
{
    int i;
    int left_size = 0, right_size = 0;
    int sum = 0;
    for ( i = mid;i >= be; i-- )
    {
        sum = sum+L->elem[i];
        if ( left_size < sum )
            left_size = sum;
    }
    sum = 0;
    for ( i = mid+1;i <= en; i++ )
    {
        sum = sum+L->elem[i];
        if ( right_size < sum )
            right_size = sum;
    }
    int max_size = left_size+right_size;
    if (max_size > max1)
        max1 = max_size;
}

void ioc(Sq *L, int be, int en)
{
    ant++;
    if ( be != en )
    {
        int mid = (be+en)/2;
        ioc(L, be, mid);
        ioc(L, mid+1, en);
        comput(L, be, mid, en);
    }
    return ;
}

int main()
{
    int n;
    Sq L;
    ant = max1 = 0;
    scanf ( "%d", &n );
    inti(&L, n);
    create(&L, n);
    ioc(&L, 0, n-1);
    printf ( "%d %d\n", max1, ant);
    return 0;
}



顺序表应用8：最大子段和之动态规划法
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <iostream>
using namespace std;

const int MAX = 100005;
typedef struct
{
    int *elem;
    int length;
}Sq;

void inti(Sq *L, int n)
{
    L->elem = (int *)malloc(4*MAX);
}

void create(Sq *L, int n)
{
    int i, k;
    for ( i = 0;i < n; i++ )
    {
        scanf ( "%d", &k );
        if ( i != 0 )
        {
            if (L->elem[i-1] < 0)
                L->elem[i] = k;
            else
                L->elem[i] = L->elem[i-1]+k;
        }
        else
            L->elem[0] = k;
    }
}

int ioc(Sq *L, int n)
{
    int i;
    int max1 = 0;
    for ( i = 0;i < n; i++ )
    {
        if (max1 < L->elem[i])
            max1 = L->elem[i];
    }
    return max1;
}

int main()
{
    int n;
    Sq L;
    scanf ( "%d", &n );
    inti(&L, n);
    create(&L, n);
    int max1 = ioc(&L, n);
    printf ( "%d\n", max1 );
    return 0;
}



代码菜鸟，如有错误，请多包涵！！！

如有帮助记得支持我一下，谢谢！！！

我_是好人
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表练习题.exe
11-07
顺序表练习题.exe
浙江理工大学数据结构真题.zip
07-29
为了应对浙江理工大学991考试，考生不仅需要理解这些理论知识，还要具备将理论应用于实际问题的能力，通过历年真题的练习，可以提高解题技巧，了解题目的难度和出题趋势。因此，这份近十年的数据结构真题集是宝贵的...
【线性表的基本操作】
qq_61369552的博客
09-20 352
线性表的基本操作
数据结构习题（顺序表）
weixin_62802660的博客
11-22 1247
SeqList merge(SqList a,SqList b,SqList &c)//传入线性表 a,b。if(iL->Length+1||L->Length>=MaxSize)//条件判断。if（i=L->Length||L->Length==0)//判断条件。if(L.data[i]>=s&&L.data[i]=t||L.Length==0)//空表且不满足的情况判断。
顺序表练习题
sin_0119的博客
09-25 215
顺序表习题
山理工-知到-大学生国家安全教育-第一章测试答案
qq_74330761的博客
12-17 4074
山理工-知到-大学生国家安全教育-第一章测试答案
武汉理工大学复试算法设计练习题（学长自己写的，其他要钱的都是盗版）
03-24
武汉理工大学的复试算法设计练习题是一份宝贵的资源，由学长亲自编写，旨在帮助考生准备算法设计相关的面试或考试。这份资料与其他收费版本不同，它免费提供，避免了盗版问题，体现了分享与教育的精神。 在提供的...
山东大学操作系统复习题答案计算题.doc
01-03
"山东大学操作系统复习题答案计算题.doc" 本资源是山东大学操作系统复习题答案计算题的答案文档，包含了多个问题的解决方案和解释。下面是对每个问题的详细解释： 一、平均周转时间和平均带权周转时间的计算 在这...
PTA—C语言数据结构：顺序表.ppt
10-11
本文件"PTA—C语言数据结构：顺序表.ppt"是针对PTA（Programming Training Assistant）平台上数据结构课程的一个教学资源，专门探讨了顺序表这一基本数据结构，并提供了相关练习题的解答。下面我们将详细讨论顺序表...
Java—计算题
qq_45885219的博客
10-08 599
Java—计算题 Description 一个简单的计算，你需要计算f(m,n)，其定义如下： 当m=1时，f(m,n)=n； 当n=1时，f(m,n)=m； 当m>1,n>1时，f(m,n)= f(m-1,n)+ f(m,n-1) Input 第一行包含一个整数T（1<=T<=100），表示下面的数据组数。 以下T行，其中每组数据有两个整数m，n（1<=m，n<=2000），中间用空格隔开。 Output 对每组输入数据，你需要计算出f(m,n)，并输出。每个结果占一行
C语言程序设计基础OJ练习题（实验一顺序结构）
Gyp郭小帅的博客
01-17 8171
一、C语言实验——Hello World!（printf练习） Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Problem Description 很高兴你能上机实践所学的C语言知识！ 编程不是在课本上的几页纸就能学会的，你必须多思考、多上机才能真正学会一门编程语言，这也是我们出这些题目的初衷。 这些题目都是课本...
顺序表的习题
m0_62397453的博客
04-26 1511
文章目录一、题目二、源代码三、运行结果总结 一、题目 题目：实现顺序表各种基本运算的算法 要求： 1、建立一个顺序表，输入n个元素并输出； 2、查找线性表中的最大元素并输出； 3、在线性表的第i个元素前插入一个正整数x； 4、删除线性表中的第j个元素； 5、将线性表中的元素按升序排列； 6、将线性表中的元素就地逆序（只允许用一个暂存单元）； 二、源代码 为了方便大家食用，直接讲代码放出来，大家可以直接复制去运行的试一下。 #define _CRT_SECURE_NO_WARNINGS 1 #inclu
山东理工sdut PTA实验九答案1~15
unicornnnqz的博客
02-16 4172
C语言 山东理工PTA
数据结构第二章线性表顺序表练习题及答案P19
qq_41834729的博客
10-16 6310
#数据结构第二章线性表顺序表练习题及答案P19 **1、**从顺序表中删除具有最小值的元素(假设唯一)并由函数返回被删元素的值。 空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行 算法思想：搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素填补空出的原最小值元素的位置 bool Del_Min(SeqList &L,ElemType &value){ if(L.length<=0) return false; int pos=0; value
【数据结构初阶】 顺序表三道题，带你见力扣
每天都要坚持刷题的博客
07-28 628
顺序表的补充和三道题，来看看把
山东理工大学：PTA实验七：参考答案与解析（2023）
2301_79810148的博客
12-08 3605
如题的参考答案、加点解析
顺序表常见算法题（全）
qq_983030560的博客
01-03 513
顺序表常见算法题的汇总，有详细的思路讲解。
初阶数据结构：顺序表相关题目练习
最新发布
qq_71806743的博客
01-18 1039
思路（时间复杂度 O(n^2) 空间复杂度 O(1)）：遍历数组，若数组元素等于val，将数组后面元素整体前移覆盖，若不等于下标加1。思路（时间复杂度 O(n) 空间复杂度 O(n)）：开辟等大小空间，将每个元素拷贝一份到新空间中，最后全部拷贝回去。注：（优化）当nums2中的元素插入完成，nums1没有插入完成无，需再进行插入操作，数组中数据本就有序。思路（时间复杂度 O(n) 空间复杂度 O(n)）：开辟一块相同大小的空间，将原数组中。遍历完成后，将新空间中的数据再拷贝回原数组中。
山东理工大学pta链表
09-01
山东理工大学pta链表是指在山东理工大学pta平台上关于链表相关题目的集合。这些题目可以通过使用C语言来解决。比如，可以通过C语言中的链表操作来完成顺序链表的建立、链表的逆序以及解决约瑟夫问题等。对于这些题目...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值