数据结构PTA

title: 曲师大计院20级的PTA
categories:
  - 数据结构
tags:
  - PTA
toc: true

第一章 绪论

判断题

1-1

数据元素是数据的最小单位。F(数据项)

1-2

数据的逻辑结构是指数据的各数据项之间的逻辑关系。F（数据元素之间）

1-3

数据结构概念包括数据之间的逻辑结构、数据在计算机中的存储方式和数据的运算三个方面。T

1-4

数据结构的抽象操作的定义与具体实现有关。F

1-5

算法和程序没有区别，在数据结构中二者是通用的。F

1-6

数据结构包括数据对象集以及它们的逻辑结构和物理结构，还包括与数据对象相关联的操作集，以及实现这些操作的高效的算法。T

选择题（错题：2-9,2-13）

2-1

在 Data_Structure = (D，R)中，D 是（ ）的有限集合。

A.数据元素

2-2

以下关于数据结构的说法中错误的是（ ）。

A.数据结构相同，对应的存储结构也相同

2-4

算法分析的目的是( )

C.分析算法的效率以求改进

2-5

算法分析的两个主要方面是( )

A.空间复杂度和时间复杂度

2-6

采用链结构存储线性表时，其地址（ ）。

B.连续不连续都可以

2-7

一个正确的算法应该具有 5 个特性，除输入、输出特性外，另外 3 个特性是（ ）。

A.确定性、可行性、有穷性

2-8

算法的时间复杂度取决于（ ）

C.问题的规模和待处理数据的初态

2-9

以下数据结构中，哪一个是线性结构（ ）

D.串

2-10

以下数据结构中，（ ）是非线性数据结构

B.字符串

2-11

算法的时间复杂度与（ ）有关。

A.问题规模

2-12

以下程序段的空间复杂度为

int a = 1, b = 1, i;
for (i=0; i<=10; i++) {
  b += a;
  a = b - a;
}

B.O(1)

2-13

下列程序段的时间复杂度是（ ）。

count=0;
for(k=1;k<=n;k*=2)
 for(j=1;j<=n;j++)
   count++;

C.O(nlog2n)

2-14

下面说法中，错误的是（ ）。

ⅰ.算法原地工作的含义是指不需要任何额外的辅助空间

ⅱ.在相同规模n下，复杂度为O(n)的算法在时间上总是优于复杂度为O(2n)的算法

ⅲ.所谓时间复杂度，是指最坏情况下估算算法执行时间的一个上界

ⅳ.同一个算法，实现语言的级别越高，执行效率越低

C.ⅰ,ⅳ

2-15

算法的计算量的大小称为算法的。

B.复杂度

2-16

在下面的程序段中，对x的赋值语句的频度为（ ）

for (i=1;i<=n;i++)
    for (j=1;j<=n;j++)
      x=x+1;

C.O(n2)

2-17

下面程序段的时间复杂度是 ( )

i ＝ 0；
while（i<=n）
     i = i * 3；

D.O(log3n)

填空题（错题：4-1, 4-4, 4-6，4-7，4-10）

4-1

算法效率的比较

假设为解决某问题而设计的若干算法的时间复杂度分别为：

A) O(n) B) O(n2) C) O(log2​n) D) O(nlog2​n) E) O(2n) F) O(n​) G) O(n!) H) O(1) I) O(n**n​) J) O(n**n)

这些算法按效率由高到低的顺序是 HCFADIBEGJ

4-2

基本术语

数据 是客观事物的符号表示，是所有能输入到计算机中并被计算机程序处理的符号的总称。

4-3

数据结构的数学定义

数据结构的数学定义为一个二元组：

D**S=(D,R)

其中：D 是数据元素的有限集，R 是 D 上的关系 的有限集。

4-4

存储结构存储结构包括数据元素的表示和关系的表示。

4-5

基本术语

抽象数据类型 一般指由用户定义的、表示应用问题的数学模型，以及定义在该模型上的一组操作。

4-6

在数据结构中，数据的逻辑结构分为线性结构和非线性结构 。

4-7

数据结构由数据的逻辑结构、存储结构 和运算|操作三部分组成。

4-8

算法的特性

一个算法必须满足以下五个重要特性：

(1) 有穷性 一个算法必须总是在执行有穷步后结束，且每一步都可以有穷有时间内完成。

(2) 确定性 一个算法中每一条指令必须有确切的含义。

(3) 可行性 算法中的所有操作都可以通过已经实现的基本操作运算执行有限次来实现。

(4) 输入一个算法有零个或多个输入。

(5) 输出一个算法有一个或多个输出，它们是算法进行信息加工后得到的结果。

4-9

基本术语

数据元素是数据的基本单位，数据项是数据的不可分割最小单位。其中：前者在计算机中通常作为一个整体进行考虑和处理，它可以由一个或多个后者组成。

4-10

数据的实例

观察下面的表格：

学号	姓名	性别	语文	数学	物理	化学	英语	总分
15160101	王克强	男	87	95	93	76	84	435
15160102	刘铭志	男	77	82	80	97	95	431
15160103	孙勇	男	78	85	87	86	65	401
15160104	李瀚东	男	93	82	72	75	95	417
15160105	赵敏	女	95	90	88	82	96	451
15160106	张毅	男	78	76	65	81	80	380
15160107	柳青	女	82	91	82	84	85	424
15160108	蔡文婷	女	85	78	80	86	95	424

整张表格称为一个 数据对象，其中每一行称为一个 数据元素，任意一行中的每一个栏目称为一个数据项。

4-11

沃斯的名言

瑞士科学家尼古拉斯·沃斯(Niklaus Wirth)有一句在计算机领域里人尽皆知的名言：

算法 + 数据结构 = 程序

编程题

7-1 求最小值和次小值 (25 分)

#include<iostream>
using namespace std;
int main()
{
    int n,x;
    cin>>n;
    cin>>x;
    if(n>1){
    int mini = x;
    int mini2 = x;
    int a[n]={x};
    for(int i=1;i<n;i++)
    {
        cin>>a[i];
        if(mini>a[i])mini=a[i];
    }

    for(int i=0;i<n;i++)
    {
        if(a[i]==mini)continue;
        if(mini2==mini)mini2=a[i];
        if(mini2>a[i])mini2=a[i];
    }
    if(mini==mini2)
        cout<<"There is no second smallest element"<<endl;
    else
        cout<<mini<<" "<<mini2;
    }
    else
    {
        cout<<"Invalid Input"<<endl;
    }

    return 0;
}

7-2 求素数个数 (30 分)

#include<iostream>
using namespace std;

int main()
{
    int n,num=0;
    cin>>n;
        int *a=new int[n+1];
        for(int i=2;i<=n;i++)
            a[i]=1;
        a[0]=a[1]=0;
        for(int i=2;i*i<=n;i++)
        {
            if(a[i])
            {
                for(int j=2*i;j<=n;j+=i)
                    a[j]=0;
            }
        }
        for(int i=2;i<=n;i++)
        {
            if(a[i])num++;
        }
        cout<<num<<endl;
    return 0;
}

/*
#include<iostream>
using namespace std;

int main()
{
    int n,num=1,flag=1;
    cin>>n;
    if(n==1)cout<<"0"<<endl;
    else if(n==2)cout<<"1"<<endl;
    else
    {
        for(int i=3;i<=n;i+=2)
        {
            for(int j=3;j*j<=i;j+=2)
            {
                if(i%j==0)
                {
                    flag=0;
                    break;
                }
            }
            if(flag)
                num++;
            flag=1;
        }
        cout<<num<<endl;
    }
    return 0;
}
*/
/*
#include<iostream>
using namespace std;

int main()
{
    int n,num=0,flag=1;
    cin>>n;
    for(int i=2;i<=n;i++)
    {
        for(int j=2;j*j<=i;j++)
        {
            if(i%j==0)
            {
                flag=0;
                break;
            }
        }
        if(flag)
        {
            num++;
        }
        flag=1;
    }
    cout<<num<<endl;
    return 0;
}
*/

第二章 线性表

判断题（错题：1-2,1-4,1-15,1-17）

1-1

顺序存储方式只能用于存储线性结构。F

1-2

在顺序表中取出第i个元素所花费的时间与i成正比。F

1-3

线性表的顺序存储表示优于链式存储表示。F

1-4

带头结点的单循环链表中，任一结点的后继结点的指针域均不空。T

1-5

顺序表 - 存储结构

顺序表中逻辑上相邻的元素，其物理位置也一定相邻。T

1-6

链式存储的优点是插入、删除元素时不会引起后续元素的移动，缺点是只能顺序访问各元素。T

1-7

线性表若采用链式存储结构时，要求内存中可用存储单元的地址一定不连续。F

1-8

链表是采用链式存储结构的线性表,进行插入、删除操作时，在链表中比在顺序存储结构中效率高。T

1-9

若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用顺序表存储最节省时间。T

1-10

对于顺序存储的长度为N的线性表，删除第一个元素和插入最后一个元素的时间复杂度分别对应为O(1)和O(N)。F

1-11

在线性表的顺序存储结构中，插入和删除元素时，移动元素的个数与该元素的位置有关。T

1-12

顺序存储方式的优点是存储密度大，且插入、删除运算效率高。F

1-13

在具有N个结点的单链表中，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。F

1-14

线性表采用链式存储表示时，所有结点之间的存储单元地址可以连续也可以不连续。T

1-15

在单链表中，要访问某个结点，只要知道该结点的指针即可。因此，单链表是一种随机存取结构。F

1-16

在具有头结点的链式存储结构中，头指针指向链表中的第一个元素结点。F

1-17

在一个设有头指针和尾指针的单链表中，执行删除该单链表中最后一个元素的操作与链表的长度无关。F

1-18

循环链表可以做到从任一结点出发，访问到链表的全部结点。T

1-19

在单链表中，逻辑上相邻的元素，其物理位置必定相邻。F

1-20

在双向链表中，可以从当前结点出发访问到任何一个结点。T

选择题(错题：2-10,2-13,2-16,2-20)

2-1

在一个长度为n的顺序表中，向第i个元素(1≤i≤n+1)位置插入一个新元素时需要从后向前移动多少个元素。

B.n-i+1

2-2

对于线性表，在顺序存储结构和链式存储结构中查找第k个元素，其时间复杂性分别是多少？

D.O(1)和O(k)

2-3

在顺序结构表示的线性表中，删除第i个元素（数组下标为i-1)，需要把后面的所有元素都往前挪一位，相应的语句是：

for (___________ )
            PtrL->Data[j-1]=PtrL->Data[j];

其中空缺部分的内容应该是

A.j = i; j< = PtrL->Last; j++

2-4

向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动的元素个数为（ ）

B.63.5

2-5

顺序表是线性表的( )

B.顺序存储结构

2-6

以下说法错误的是 ( )。

C.在链表上实现读表元运算的平均时间复杂度为O（1）

2-7

哪个选项不是线性表的链式存储结构（ ）

B.顺序表

2-8

在向表中第i个元素（1≤i≤n+1）位置插入一个新元素时，为保持插入后表中原有元素的相对次序不变，需要从后向前依次后移（ ）个元素。

B.n-i+1

2-9

在删除表中第i个元素时，同样地，为保持删除后表中原有元素的相对次序不变，需要从前向后依次前移（ ）个元素。

A.n-i

2-10

与单链表相比，双链表的优点之一是（）。

D.顺序访问相邻结点更加灵活

2-11

在单链表中，要删除某一指定结点，必须先找到该结点的（）。

A.直接前驱

2-12

循环链表的主要优点是（）。

D.从表中的任意结点出发都能扫描到整个链表

2-13

若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点，则采用（）存储方式最节省运算时间。

D.带表头附加结点的双循环链表

2-14

单链表又称为线性链表，在单链表上实施插入和删除操作（ ）。

B.不需移动结点，只需改变结点指针

2-15

链表不具有的特点是( )。

A.可随机访问任一个元素

2-16

下面关于线性表的叙述中，错误的是。

B.线性表采用顺序存储，便于进行插入和删除操作。

2-17

单链表L（带头结点）为空的判断条件是。

B.L->next==NULL

2-18

在单链表指针为p的结点之后插入指针为s的结点，正确的操作是：（ ）。

B.s->next=p->next;p->next=s

2-19

对于一个头指针为head的带头结点的单链表，判定该表为空表的条件是（ ）

B.head→next==NULL

2-20

设一个链表最常用的操作是在末尾插入结点和删除尾结点，则选用( )最节省时间。

D.带头结点的双循环链表

填空题

4-1

顺序表 - 地址计算

假设顺序表第 1 个元素的内存地址是 100，每个元素占用 2 字节内存空间，则第 5 个元素的内存地址是 108

4-2

在有n个元素的顺序表中删除任意一个元素所需移动元素的平均次数为 （n-1)/2

4-3

在有n个元素的顺序表中的任意位置插入一个元素所需移动元素的平均次数为 n/2

4-4

在长度为n的顺序表L中将所有值为x的元素替换成y，该算法的时间复杂度为 O(n)

4-5

在顺序表中，逻辑上相邻的元素，其物理位置 一定 相邻。在单链表中，逻辑上相邻的元素，其物理位置 不一定 相邻。

4-6

对于顺序表的插入算法insert_sqlist来说，若以结点移动为标准操作，则插入算法的在最坏情况下的移动次数为 n ，时间复杂度是 O(n)。在平均情况下的移动次数为 n/2 ，时间复杂度是 O(n)。

4-7

线性表L=(a1, a2, ... , an)用数组表示，假定删除表中任一元素的概率相同，则删除一个元素平均需要移动元素的个数是 (n-1)/2

程序填空题

5-1 顺序表删除操作。

#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define MAXSIZE 100
typedef int datatype;

typedef struct {
    datatype *elem; 
    int length;
} SqList;

int ListDelete_Sq(SqList &L, int i) {
    if ((i < 1) || (i > L.length))
        return ERROR; 
    for (int j = i; j <= L.length; j++)
        ; (2')
    --L.length; 
    return OK;
}


int main() {
    SqList L;
    int i = 0, n,a;
    datatype e;
    L.elem = new datatype[MAXSIZE];
    L.length = 0;
    cin >> n;
    for (i=0;i<n;i++) 
        cin >> L.elem[i];
    L.length = i;
    cin >> a;
    if (ListDelete_Sq(L, a))
        {
            for (i = 0; i < L.length; i++)
                if(i==0)
                 cout  << L.elem[i];
                else
                 cout  << " " << L.elem[i];                
        }
    else
        cout << "ERROR";
    return 0;
}

5-2单链表删除操作。

#include<iostream>
using namespace std;
#define OK 1
#define ERROR 0
typedef int ElemType;

typedef struct LNode {
    ElemType data;
    struct LNode *next; 
} LNode, *LinkList; 

void CreateList(LinkList &L, int n) ;//该函数未显示细节 

int ListDelete_L(LinkList &L, int i) {
    LinkList p, q;
    int j;
    p = L;
    j = 0;
    while((p->next) && (j <i)) (2')
    {
        p = p->next;
        ++j;
    }
    if (!(p->next) || (j > i - 1))
        return ERROR; 
    q = p->next;  
    p->next=q->next;(2')
    delete q; 
    return OK;
} 


void print(LinkList &L)
{
    LinkList p;
    int flag=1;
    p = L->next;
    while (p) {
        if(flag)
            cout << p->data;
        else
            cout << " "<< p->data;
        flag=0;
        p = p->next;
    }
}

int main() {
    LinkList L;
    ElemType e;
    int length;
    int i;
    cin >> length;
    CreateList(L, length);    
    cin >> i;
    ListDelete_L(L,i);
    print(L);
    return 0;
}

函数题

6-1 求顺序表最大值 (10 分)

int GetMax(SqList L)
{
   int maxi=0;
   for(int i=0;i<L.length;i++)
   {
       if(maxi<L.elem[i])maxi=L.elem[i];
   }
   return maxi;
}

6-2 单链表逆置* (10 分)

void Reverse(NODE *head)
{
    NODE *p,*p1,*p2,*p3;
    p = head->next;
    p1 = head;
    p1->next = NULL;
    while(p!=NULL)
    {
        p2 = p;
        p = p->next;
        p2->next = p1->next;
        p1->next = p2;
    }
}

6-3 单链表统计正数个数 (6 分)

int PositiveInt(LinkList L)
{
    LNode *p;
    int n=0;
    p = L->next;
    while(p!=NULL)
    {
        if(p->data>0)n++;
        p = p->next;
    }
    return n;
}

编程题

7-1 学生顺序表的建立 (10 分)

法一：
#include<iostream>
#include<string>
#include<iomanip>
using namespace std;
struct Node
{
    int id;
    string name;
    float s1,s2,s3;
    Node *next;
};
int main()
{
    int n;
    int id;
    string name;
    float s1,s2,s3;
    Node *p,*first,*last=NULL;
    last = new Node;
    first = last;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        cin>>id>>name>>s1>>s2>>s3;
        p = new Node;
        p->id = id;
        p->name = name;
        p->s1 = s1;
        p->s2