Data_Structure02-线性表

PTA实验作业解析

最新推荐文章于 2022-04-09 13:43:02 发布

weixin_33975951

最新推荐文章于 2022-04-09 13:43:02 发布

阅读量222

点赞数

CC 4.0 BY-SA版权

文章标签：数据结构与算法 git c/c++

原文链接：http://www.cnblogs.com/lanxiang/p/8641408.html

本文详细解析了PTA实验作业中的三个题目，包括最长连续递增子序列、集合的基本运算和两个有序序列的中位数。通过伪代码描述了设计思路，并分析了调试过程中遇到的问题。

一、PTA实验作业

本周要求挑3道题目写设计思路、调试过程。设计思路用伪代码描述。
1、顺序表选择一题（6-2,6-3,7-1选一题），代码必须用顺序结构抽象数据类型封装
2、单链表选择一题（6-1不能选）
3、有序表选择一题

选题：

1、7-1 最长连续递增子序列（20 分）
2、6-4 集合的基本运算（单链表）（10 分）
3、7-3 两个有序序列的中位数（25 分）

题目1：7-1 最长连续递增子序列

1、设计思路

#头文件

结构体LNode{
    定义整型变量x; //用来存储记录的数
    定义整型变量y; //用来记录连续的个数 
}A[100001];

int main(){
    定义整型变量i,j; //用于循环
    定义 n;            //用于记录序列的长度
    定义 max<-1,c;     //max记录连续最大值
                     //c记录连续最大的开始
    输入n;
    /*****输入序列*****/
    for i<-0 to n-1 do
        输入A[i].x;    
    end
    /*将连续个数初始化为1*/
    for i<-0 to n-1 do
        A[i].y<-1;  
    end
    /*****判断递增*****/
    for i<-0 to n-1 do
        for j<-i+1 to n-1 do
            if(后一个数的值 > 前一个数的值）
                then A[i].y++;  //i处的记录加一
                else break; 
        end
    end
    /*****判断最大值*****/   
    for i<-0 to n-1 do
        if( i的连续的个数 > max )
            then max<-A[i].y;
                 c<-i;      //从i开始的序列
    end
    /*****输出最大子列*****/  
    for i<-c to c+max-2 do
        输出 "A[i].x "        //末尾有空格
    end
    输出"A[c+max-1].x"            //末尾没空格
}

2、代码截图

3、PTA提交列表说明

第一次编译错误是因为没有修改编译器的缘故，C++的代码用C的编译器。

题目2：6-4 集合的基本运算（单链表）

1、设计思路

/*********裁判测试程序**********/
#include <stdio.h>
#include <malloc.h>
typedef char ElemType;
typedef struct LNode    //定义单链表结点类型
{
    ElemType data;
    struct LNode *next;
} LinkList;
void DispList(LinkList *L);  //输出链表元素，每个结点元素值以空格符间隔，以换行符结束。
void CreateListR(LinkList *&L,ElemType a[],int n); //用数组元素值尾插法创建链表。
void DestroyList(LinkList *&L);//销毁链表。
void sort(LinkList *&L)     //单链表元素递增排序。
void Union(LinkList *ha,LinkList *hb,LinkList *&hc)  //求两有序集合ha、hb的并集hc。
void InterSect(LinkList *ha,LinkList *hb,LinkList *&hc) //求两有序集合ha、hb的的交集hc。
void Subs(LinkList *ha,LinkList *hb,LinkList *&hc)  //求两有序集合ha、hb的差集hc。
int main()
{
    LinkList *ha,*hb,*hc;
    ElemType a[100]={0};
    ElemType b[100]={0};
    int i=0;
    char ch;
    while((ch=getchar())!='\n')
    {
        a[i++]=ch;
    }
    CreateListR(ha,a,i);
    i=0;
    while((ch=getchar())!='\n')
    {
        b[i++]=ch;
    }
    CreateListR(hb,b,i);
    printf("A: ");DispList(ha);
    printf("B: ");DispList(hb);
    sort(ha);
    sort(hb);
    printf("sorted A: ");DispList(ha);
    printf("sorted B: ");DispList(hb);
    Union(ha,hb,hc);
    printf("Union C: ");DispList(hc);
    InterSect(ha,hb,hc);
    printf("InterSect C: ");DispList(hc);
    Subs(ha,hb,hc);
    printf("Subs C: ");DispList(hc);
    DestroyList(ha);
    DestroyList(hb);
    DestroyList(hc);
    return 0;
}

/* 请在这里填写答案 */

/*输出链表元素，每个结点元素值以空格符间隔，以换行符结束。*/
void DispList(LinkList *L){  
    定义结构体类型指针p;
    p指向L;
    while p //当p不为空时进入循环
        do 输出p->next;
        p <- p->next;
        end
    输出回车;
}
/*用数组元素值尾插法创建链表。*/
void CreateListR(LinkList *&L,ElemType a[],int n){ 
    定义结构体类型指针p,q;
    给L申请结构体内存空间;
    L->next <- NULL;    
    P指向L;
    定义整型变量 i<-0;
    while n--
        do 给q申请结构体内存空间;
        q->data <- a[i++];  //赋值后，i++
        q->next <- 0;
        p->next 指向 q;
        p 指向 p->next;
        end
    L 指向 L->next;       //去除空头
}
/*****销毁链表*****/
void DestroyList(LinkList *&L){
    定义结构体类型指针p;
    while L
        do P指向L;
        L <- L->next;
        清除p的内存空间;
        end
}
/***单链表元素递增排序。***/
void sort(LinkList *&L) {   
    if !L  //如果L为空，则返回
        then return;
    定义整型变量 temp;  //用于交换数据
    定义结构体类型指针p,q;
    for p<-L to p为空
        for q<-L to q为空
            if p指向的数据 < q指向的数据
                then 交换p,q所指向的数据
        end
    end
}
/***求两有序集合ha、hb的并集hc。***/
void Union(LinkList *ha,LinkList *hb,LinkList *&hc){  
    定义结构体类型指针pa,pb,pc,pl;
    pa 指向 ha;
    pb 指向 hb;
    给hc申请结构体内存空间
    hc->next <- NULL ;
    pc 指向hc;
    while pa&&pb    //pa,pb均不为空
        do 给pl申请结构体内存空间
        if pa指向的数据 < pb指向的数据
            then pl指向的数据 <- pa指向的数据
            pl->next <- NULL;
            pc->next 指向 pl;
            pa 指向 pa->next;
        elseif pa指向的数据 > pb指向的数据
            then pl指向的数据 <- pb指向的数据
            pl->next <- NULL;
            pc->next 指向 pl;
            pb 指向 pb->next;
        else //pa指向的数据 = pb指向的数据
            then pl指向的数据 <- pa指向的数据
            pl->next <- NULL;
            pc->next 指向 pl;
            pa 指向 pa->next;
            pb 指向 pb->next;
        pl 指向 pl->next;
    end
    /****将不为空的剩余数据依次添加到pl后面****/
    while pa 
        do 给pl申请结构体内存空间
        pl指向的数据 <- pa指向的数据
        pl->next <- NULL;
        pc->next 指向 pl;
        pa 指向 pa->next;
        pc 指向 pc->next;
    end
    while pb 
        do 给pl申请结构体内存空间
        pl指向的数据 <- pb指向的数据
        pl->next <- NULL;
        pc->next 指向 pl;
        pb 指向 pb->next;
        pc 指向 pc->next;
    end
    hc 指向 hc->next; //去除空头
}
/***求两有序集合ha、hb的的交集hc。***/
void InterSect(LinkList *ha,LinkList *hb,LinkList *&hc) {
    定义结构体类型指针pa,pb,pc,pl;
    pa 指向 ha;
    pb 指向 hb;
    给hc申请结构体内存空间
    hc->next <- NULL;
    pc 指向 hc;
    while pa&&pb    //pa,pb均不为空
        do 给pl申请结构体内存空间
        if pa指向的数据 = pb指向的数据
            then pl指向的数据 <- pa指向的数据
            pl->next <- NULL;
            pc->next 指向 pl;
            pa 指向 pa->next;
            pb 指向 pb->next;
            pc 指向 pc->next;
        elseif pa指向的数据 < pb指向的数据
            then pa 指向 pa->next;
        else //pa指向的数据 > pb指向的数据
            pb 指向 pb->next;
    end
    hc 指向 hc->next; //去除空头
}
/****求两有序集合ha、hb的差集hc。*****/    
void Subs(LinkList *ha,LinkList *hb,LinkList *&hc){ 
//hc已经是两个有序集合ha，hb的交集   
    定义结构体类型指针pa,pc,p,pl;
    pa 指向 ha;
    给pc申请结构体内存空间
    pc->next <- NULL;
    p 指向 hc;
    while pa&&pb    //pa,pb均不为空
        do if hc指向的数据 = pa指向的数据
            pa 指向 pa->next;
            hc 指向 hc->next;
            continue;
        else 给pl申请结构体内存空间
            pl指向的数据 <- pa指向的数据;
            pl->next <- NULL;
            pc->next 指向 pl;
            pa 指向 pa->next;
        pc 指向 pc->next;
    end
    while pa
        do 给pl申请结构体内存空间
        pl指向的数据 <- pa指向的数据
        pl->next <- NULL;
        pc->next 指向 pl;
        pa 指向 pa->next;
        pc 指向 pc->next;
    end
    p 指向 p->next;
    hc 指向 p;
}

2、代码截图

3、PTA提交列表说明

    第一次提交错是因为求并集和差集的函数有错：
并集中的错误是因为一个判断少了一个；
而差集的错误是因为一开始没有发现，hc已经是ha，hb的交集。

题目3：7-3 两个有序序列的中位数

1、设计思路

#头文件
#定义宏 MaxSize 100000

重定义结构体 LNode{
    定义int类型的 data;
    定义结构体指针 next;
}为LinkList;

函数声明：
void CreateListR( LinkList *&L,ElemType a[],int n );    // 创建链表 
void Union(LinkList *ha,LinkList *hb,LinkList *&hc);    //求并集 

int main(){
    定义int类型的n;
    定义int类型的数组a[MaxSize];
    定义int类型的数组b[MaxSize];
    输入n;
    定义int类型的i;
    for i=0 to n-1
        输入a[i]
    end
    CreateListR(h1,a,i);    //将数组a的值创建为单链表
    for i=0 to n-1
        输入b[i]
    end
    CreateListR(h2,b,i);    //将数组a的值创建为单链表
    Union(h1,h2,h3);        //将单链表的h1,h2合并为h3
    i<-1;
    r 指向 h3;
    while i<n
        do r指向r->next;
        i++
    end
    输出 r->data;
    return 0;
}
void CreateListR( LinkList *&L,ElemType a[],int n ){
    定义结构体指针p,q;
    给L申请指针内存空间;
    L->next <- NULL;
    p 指向 L；
    定义int类型的 i<-0;
    while n--
        do 给q申请指针内存空间
        q指向的数据 <- a[i];
        q->next <- NULL;
        p->next 指向 q;
        p 指向 p->next;
    end
    L 指向 L->next
}
void Union(LinkList *ha,LinkList *hb,LinkList *&hc){  
        定义结构体类型指针pa,pb,pc,pl,pm;
        pa 指向 ha;
        pb 指向 hb;
        给hc申请结构体内存空间
        hc->next <- NULL ;
        pc 指向hc;
        while pa&&pb    //pa,pb均不为空
            do 给pl申请结构体内存空间
            if pa指向的数据 < pb指向的数据
                then pl指向的数据 <- pa指向的数据
                pl->next <- NULL;
                pc->next 指向 pl;
                pa 指向 pa->next;
            elseif pa指向的数据 > pb指向的数据
                then pl指向的数据 <- pb指向的数据
                pl->next <- NULL;
                pc->next 指向 pl;
                pb 指向 pb->next;
            else //pa指向的数据 = pb指向的数据
                then pl指向的数据 <- pb指向的数据
                pl->next <- NULL;
                pc->next 指向 pl;
                pb 指向 pb->next;
                给pm申请指针内存空间
                pm指向的数据 <- pa指向的数据
                pm->next <- NULL;
                pc->next 指向 pm;
                pa 指向 pa->next;
            pc 指向 pc->next;
        end
        /****将不为空的剩余数据依次添加到pl后面****/
        while pa 
            do 给pl申请结构体内存空间
            pl指向的数据 <- pa指向的数据
            pl->next <- NULL;
            pc->next 指向 pl;
            pa 指向 pa->next;
            pc 指向 pc->next;
        end
        while pb 
            do 给pl申请结构体内存空间
            pl指向的数据 <- pb指向的数据
            pl->next <- NULL;
            pc->next 指向 pl;
            pb 指向 pb->next;
            pc 指向 pc->next;
        end
        hc 指向 hc->next; //去除空头
}

2、代码截图

3、PTA提交列表说明

第一次提交编译错误原因：未修改编译器；
接下来的错误均为最小N的错误，当n=1时，应该输出最小的数，而我输出的是一个地址，经过调试发现，在并集里面有一句代码“if( ha->next==NULL&&hb->next==NULL ) return;”导致并集为空，

二、截图本周题目集的PTA最后排名

1、顺序表PTA排名

2.链表PTA排名

3.我的总分

    本次两个题集的总分为227分，自评分为2分

三、本周学习总结

1.谈谈你本周数据结构学习时间是如何安排，对自己安排满意么，若不满意，打算做什么改变？

1、如何安排：
    首先必须是在上课认真听讲，完成随堂练习和互动，其次，在课堂外，多加训练，完成pta题集，并在时间允许的情况下，完成更多的题目，如pat等平台上的题。
2、我对我的安排感觉还比较满意，只是能空余出来的时间不多，完成pta上的题目花费太多的时间，对链表的操作还不太熟悉，需要多加联系

2.谈谈你对线性表的认识？

线性表是n（n为0时为空表）个数据元素的有限集合，他的特点是：
（1）存在唯一的一个被叫做“第一个”的数据元素，存在唯一的一个被叫做“最后一个”的数据元素。
（2）除了第一个数据元素外，其它的数据元素都有一个前驱。除了最后一个数据元素外，其它的数据元素都有一个后继。

线性表主要有两种实现方式：一种为顺序表，另一种为链表
（1）顺序表的实现主要为数组，算法比较简单，可以容易的找到第i个储存的内容，但是在插入新元素，或者删除一个元素的时候，相对麻烦。
（2）链表的逻辑结构严谨，在进行插入和删除操作时较为简便，但是，在查找元素的时候比较麻烦。