[数据结构]线性表2 C++编程作业

1 . 

在含n个元素的顺序表中，算法的时间复杂度是O(1)的是______。

A.访问第i个元素（0≤i≤n-1）和求第i个元素的前驱元素（1≤i≤n-1）

B.在第i个元素后插入一个新元素（0≤i≤n-1）

C.删除第i个元素（0≤i≤n-1）

D.将n个元素从小到大排序

2 . 

线性表的链式存储结构与顺序存储结构相比，优点是______。

A.所有的操作算法实现简单

B.便于随机存取

C.便于插入和删除元素

D.节省存储空间

3 . 

线性表采用链表存储时，存放所有存放元素的结点地址______。

A.必须是连续的

B.一定是不连续的

C.部分地址必须是连续的

D.连续与否均可以

4 . 

单链表的存储密度______。

A.大于1

B.等于1

C.小于1

D.不能确定

5 . 

对于单链表存储结构，以下说法中错误的是______。

A.一个结点的数据成员用于存放线性表的一个数据元素

B.一个结点的指针成员用于指向下一个数据元素的结点

C.单链表必须带有头结点

D.单链表中所有结点可以连续也可以不连续存放

 回答错误

解析

单链表可带、可不带头节点，两者类似。

线性表的链式存储结构特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。所以选项A表达正确，应选C。

代码表示存储结构如下：

typedef int Elemtype;

typedef struct Node

{

Elemtype data;

struct Node* next;

};

typedef struct Node* LinkList;

6 . 

链表不具备的特点是______。

A.可随机访问任一结点

B.插入删除不需要移动结点

C.不必事先估计存储空间

D.所需空间与其长度成正比

 

7 . 

以下关于链表的叙述中，不正确的是______。

A.结点中除元素值外还包括指针成员，因此存储密度小于顺序存储结构

B.逻辑上相邻的元素物理上不必相邻

C.可以根据头结点地址直接计算出第i个结点的地址

D.插入、删除运算操作方便，不必移动结点

 回答错误

解析

链表存储地址随机，非顺序存储，无法通过计算得出其他结点地址。只能通过指针索引。

Microsoft Word - 第3章.doc (tsinghua.edu.cn)

8 . 

若某线性表最常用的操作是查找序号i的元素和在末尾插入元素，则选择______存储结构最节省时间。

A.顺序表

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

C.单链表

D.带尾结点的循环单链表

9 . 

以下关于单链表的叙述中正确的是______。 Ⅰ.结点中除元素值外还包括指针成员，存储密度小于顺序表 Ⅱ.找第i个结点的时间为O(1) Ⅲ.在插入和删除操作时不必移动结点

A.仅Ⅰ、Ⅱ

B.仅Ⅱ、Ⅲ

C.仅Ⅰ、Ⅲ

D.Ⅰ、Ⅱ、Ⅲ

10 . 

有一个长度为n（n>1）的带头结点的单链表h，另设有尾指针r（指向尾结点），执行______ 操作与链表的长度有关。

A.删除单链表中的首结点

B.删除单链表中的尾结点

C.在单链表首结点前插入一个新结点

D.在单链表尾结点素后插入一个新结点

11 . 

已知一个长度为n的单链表是递增有序的，所有结点值不相同，以下叙述中正确的是______。

A.插入一个结点使之有序的算法的时间复杂度为O(1)

B.删除最大值结点使之有序的算法的时间复杂度为O(1)

C.找最小值结点的算法的时间复杂度为O(1)

D.以上都不对

12 . 

已知两个长度分别为m 和n 的递增单链表，若将它们合并为一个长度为m+n 的递减单链表，则最好情况下的时间复杂度是______。

A.O(n)

B.O(m)

C.O(m×n)

D.O(m+n)

13 . 

在一个双链表中，删除p结点（非尾结点）的操作是______。

A.p.prior.next=p.next; p.next.prior=p.prior;

B.p.prior=p.prior.prior; p.prior.prior=p;

C.p.next.prior=p; p.next=p.next.next;

D.p.next=p.prior.prior; p.prior=p.prior.prior;

14 . 

在长度为n（n≥1）的双链表L中，在p结点之前插入一个新结点s的时间复杂度为______。

A.O(1)

B.O(n)

C.O(n2)

D.O(nlog2n)

15 . 

在长度为n（n≥1）的双链表中插入一个结点p（非尾结点）要修改______个指针成员。

A.1

B.2

C.3

D.4

16 . 

在长度为n（n≥1）的双链表中删除一个结点p（非尾结点）要修改______个指针成员。

A.1

B.2

C.3

D.4

17 . 

在存储同一线性表时，以下关于单链表和双链表比较中正确的是______。

A.单链表的存储密度较双链表高

B.单链表的存储密度较双链表低

C.双链表较单链表存放更多的元素

D.单链表不能表示线性表的逻辑关系，而双链表可以

18 . 

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

A.插入、删除操作更简单

B.可以进行随机访问

C.可以省略表头指针或表尾指针

D.访问前后相邻结点更方便

19 . 

某个线性表最常用的操作是在尾结点之后插入一个结点和删除首结点，则该线性表采用______ 存储方式最合适。

A.单链表

B.仅有头结点的循环单链表

C.双链表

D.仅有尾指针的循环单链表

20 . 

与非循环单链表相比，循环单链表的主要优点是______。

A.不再需要头结点

B.已知某个结点能够容易找到它的前驱结点

C.在进行插入、删除操作时，能更好地保证链表不断开

D.从表中任意结点出发都能遍历整个链表

21 . 

非空循环单链表head的尾结点p满足______。

A.p.next==null

B.p==null

C.p.next==head

D.p==head

22 . 

在长度为n（n≥1）的循环单链表L中，删除尾结点的时间复杂度为______。

A.O(1)

B.O(n)

C.O(n2)

D.O(nlog2n)

23 . 

有两个长度为n（n>1）的不带头结点的单链表，结点类型相同，A是非循环的，B是循环的，则以下正确的是______。

A.对于这两个链表来说，删除首结点的时间复杂度都是O(1)

B.对于这两个链表来说，删除尾结点的时间复杂度都是O(n)

C.循环单链表B比非循环单链表A占用更多的内存空间

D.以上都不对

 回答错误

解析

选项B正确，删除尾结点均需遍历一遍链表，所以时间复杂度都是O(n)

24 . 

有一个非空循环双链表，在结点p之前插入结点q的操作是______。

A.p.prior=q; q.next=p; p.prior.next=q; q.prior=p.prior;

B.p.prior=q; p.prior.next=q; q.next=p; q.prior=p.prior;

C.q.next=p; q.prior=p.prior; p.prior=q; p.prior.next=q;

D.q.next=p; q.prior=p.prior; p.prior.next=q; p.prior=q;

25 . 

有一个非空循环双链表，在结点p之后插入结点q的操作是q.next=p.next; p.next=q; q.prior=p; ______。

A.p.next=q;

B.q.prior.next=q;

C.q.next.prior=q;

D.q.next.next=q;

26 . 

在长度为n的______ 上，删除尾结点的时间复杂度为O(1)。

A.单链表

B.双链表

C.循环单链表

D.循环双链表

 回答错误

解析

27 . 

线性表有一个特点（） 。

A.至少有两个元素，即开始元素和终端元素

B.若没有开始元素，则一定没有终端元素

C.每个元素必须有一个前趋元素

D.任何一个元素都还可能既是开始元素又是终端元素

解析

线性表可以是空表，此时既没有开始元素也没有终端元素。

28 . 

关于线性表的正确说法是（） 。

A.每个元素都有一个前趋和一个后继元素

B.线性表中至少有一个元素

C.表中元素的排序顺序必须是由小到大或由大到小

D.除第一个元素和最后一个元素外，其余每个元素有且仅有一个前趋和一个后继元素

解析

线性表属典型的线性结构。

29 . 

线性表的顺序存储结构是一种（）。

A.随机存取的存储结构

B.顺序存取的存储结构

C.索引存取的存储结构

D.散列存取的存储结构

解析

若含有n个元素的线性表a采用顺序表存储，每个元素的类型为ElemType，则第i个元素ai（1≤i≤n）的存储地址为LOC(a0)+i×sizeof(ElemType)，也就是说，对于给定的序号i，在O(1)的时间内找到该元素值，这是一种随机存取的存储结构。而顺序存取是一种读写方式，不是存储方式，有别于顺序存储。

30 . 

以下关于顺序表的叙述中，正确的是（）。

A.顺序表可以利用一维数组表示，因此顺序表与一维数组在结构上是一致的，它们可以通用

B.在顺序表中，逻辑上相邻的元素在物理位置上不一定相邻

C.顺序表和一维数组一样，都可以进行随机存取

D.在顺序表中每一个元素的类型不必相同

解析

顺序表中所有元素必须连续存放，而一维数组中所有元素可以不连续存放，另外，一维数组只有按下标的存、取两个操作，而顺序表可以进行线性表的插入、删除等操作，所以选项A错误。在顺序表中，逻辑上相邻的元素在物理位置上也一定相邻，所以选项B错误。顺序表中每一个元素的类型必须相同，所以选项D错误。

31 . 

设一个顺序表L（最多可存放100个元素）目前有3个元素，第i（1≤i≤3）个元素存放在L.data[i-1]中，若把一个新元素存入L.data[5]，则（）。

A.会产生运行错误

B.L.data[0]～L.data[5]不构成一个顺序表

C.顺序表的长度大于顺序表元素个数，会降低存储空间的利用率

D.以上都不对

 回答错误

解析

顺序表是线性表的一种存储结构，线性表中所有元素是紧靠在一起的，不可能出现两个元素之间空出一个元素，当在含有3个元素的顺序表L中存入新元素L.data[5]，这不是合法的线性表运算，从而导致L.data[0]～L.data[5]不再是一个合法的顺序表。

32 . 

设一个顺序表L（最多可存放100个元素）目前有20个元素，第i（1≤i≤20）个元素存放在L.data[i-1]中，现删除L.data[5]的元素而不做元素移动，则（） 。

A.会产生运行错误

B.L.data[0]～L.data[19]不构成一个顺序表

C.顺序表的长度变为19

D.以上都不对

 回答错误

解析

顺序表是线性表的一种存储结构，线性表中所有元素是紧靠在一起的，不可能出现两个元素之间空出一个元素，当在含有20个元素的顺序表L中删除L.data[5]的元素而不做元素移动时，这不是合法的线性表运算，从而导致L.data[0]～L.data[19]不再是一个合法的顺序表。

33 . 

顺序表具有随机存取特性，指的是（）。

A.查找值为x的元素与顺序表中元素个数n无关

B.查找值为x的元素与顺序表中元素个数n有关

C.查找序号为i的元素与顺序表中元素个数n无关

D.查找序号为i的元素与顺序表中元素个数n有关

 回答错误

解析

一种存储结构具有随机存取特性指的是，对于给定的序号i，在O(1)时间内找到对应元素值。

34 . 判断题

线性表中所有元素的数据类型必须相同。

是否

解析

线性表中所有元素具有相同性质，在设计存储结构时，它们对应的数据类型也必然相同。

35 . 判断题

线性表中的结点按前趋、后继关系可以排成一个线性序列。

是否

解析

线性表是有限个相同性质的元素的序列。

36 . 判断题

空的线性表就是所有元素尚未赋值的线性表。

是否

解析

空的线性表就是长度为0的线性表。

37 . 判断题

在一个含有n（n≥1）个元素的线性表中，所有元素值不能相同。

是否

解析

在线性表中允许存在元素值相同的元素，但它们的位置是不同。

38 . 判断题

线性表中每个元素都有一个前趋元素和一个后继元素。

是否

解析

开始元素没有前趋元素，终端元素没有后继元素。

39 . 判断题

线性表的长度是线性表占用的存储空间的大小。

是否

解析

线性表的长度是指表中元素个数，属逻辑结构的概念，与线性表占用的存储空间大小无关。

40 . 判断题

线性表的存储结构大小与线性表中元素类型有关。

是否

解析

线性表的存储结构大小等于线性表中所有元素存储空间之和，而线性表中元素类型不同，每个元素所占用的存储空间大小也可能不同。

41 . 判断题

线性表的逻辑顺序总与其物理顺序一致。

是否

解析

当线性表采用链式存储结构时，其逻辑顺序与物理顺序可能不一致。

42 . 判断题

线性表的顺序存储结构优于链式存储结构。

是否

 回答错误

解析

线性表的顺序存储结构和链式存储结构各有优缺点。

43 . 判断题

顺序表具有随机存取特性，而链表不具有随机存取特性。

是否

44 . 编程题 14分

约瑟夫环

n个人排出一个环形，序号分别为1，2，...,n-1,n。从序号为1的人开始报数，报到第k个人出列。然后继续从第k+1个人开始报数。

直到所有人都出列。

给定n和k,请输出出列的人的编号序列。

比如n=8,k=3,则出列编号的序列为：

3,6,1,5,2,8,4,7

学生答案

#include <iostream>using namespace std;

typedef struct Node {

    int no;

    struct Node* next;

} Node;

Node* CreateList(int n) {

    Node* head = new Node;

    head->no = 1;

    head->next = nullptr;

    Node* p = head;

    for (int i = 1; i < n; i++) {

        Node* node = new Node;

        node->no = i + 1;

        node->next = nullptr;

        p->next = node;

        p = node;

    }

    p->next = head;  // 将最后一个节点的next指针指向头节点，形成循环链表

    return head;

}

void josephus(int n, int k) {

    Node* head = CreateList(n);

    Node* p = head;

    while (p->next != p) {  // 当链表中只剩一个节点时结束循环

        for (int i = 1; i < k - 1; i++) {  // 找到要删除的节点的前一个节点

            p = p->next;

        }

        Node* q = p->next;  // 要删除的节点

        cout << q->no << ",";

        p->next = q->next;  // 删除节点

        delete q;

        p = p->next;  // 移动到下一个节点

    }

    cout << p->no << endl;  // 输出最后剩下的节点

    delete p;  // 释放内存

}

int main(int argc, char* argv[]) {

    int n, k;

    cin >> n >> k;

    josephus(n, k);

    return 0;

}

答案

#include <algorithm>#include <iostream>using namespace std; typedef struct Node{

   int no;

   struct Node *next;

}Node;Node* CreateList(int n){

   Node *list=new Node[n];

   for(int i=0;i<n;i++){

      list[i].no = i+1;

      if(i<n-1)

         list[i].next=&list[i+1];

      else

         list[i].next=&list[0];

   }

   return list;

}void josephus(int n,int k){

   Node *head=CreateList(n);

   Node *p=head;

   for(int i=1;i<n;i++)

   {

      for(int j=1;j<k-1;j++)

         head=head->next;

      cout<<head->next->no<<",";

      head->next=head->next->next;

      head=head->next;

   }

   cout<<head->no;

   delete []p;

}int main(int argc, char *argv[]){  

   int n,k;

   cin>>n;

   cin>>k;

   josephus(n,k);

   return 0;

}