chap2 线性表作业（判断+选择）

 

判断题

1-1

对于顺序存储的长度为N的线性表，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。 (1分)

T

1-2

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

T

1-3

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

F

1-4

(neuDS)在顺序表中逻辑上相邻的元素，其对应的物理位置也是相邻的。 (1分)

T

1-5

(neuDS)所谓随机存取，就是通过首地址和元素的位序号值可以在O(1)的时间内找到指定的元素。 (1分)

T

1-6

(neuDS)顺序存储的线性表不支持随机存取。 (1分)

F

1-7

(neuDS)在顺序表上进行插入、删除操作时需要移动元素的个数与待插入或待删除元素的位置无关。 (1分)

F

1-8

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

F

1-9

若用链表来表示一个线性表，则表中元素的地址一定是连续的。 (1分)

F

1-10

将长度分别为m,n的两个单链表合并为一个单链表的时间复杂度为O(m+n)。 (1分)

F

1-11

(neuDS)单链表不是一种随机存取的存储结构。 (1分)

T

选择题

2-1

对于顺序存储的长度为N的线性表，访问结点和增加结点的时间复杂度为：(1分)

1. O(1), O(1)
2. O(1), O(N)
3. O(N), O(1)
4. O(N), O(N)

2-2

在N个结点的顺序表中，算法的时间复杂度为O(1)的操作是：(2分)

1. 访问第i个结点（1≤i≤N）和求第i个结点的直接前驱（2≤i≤N）
2. 在第i个结点后插入一个新结点（1≤i≤N）
3. 删除第i个结点（1≤i≤N）
4. 将N个结点从小到大排序

2-3

若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用哪种存储方式最节省时间？ (2分)

1. 双链表
2. 单循环链表
3. 带头结点的双循环链表
4. 顺序表

2-4

顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ ）。(2分)

1. 100
2. 105
3. 108
4. 110

2-5

(neuDS)线性表的顺序存储结构是一种( ) (2分)

1. 随机存取的存储结构
2. 顺序存取的存储结构
3. 索引存取的存储结构
4. 散列存取的存储结构

2-6

(neuDS)一个顺序表所占用的存储空间大小与( )无关。 (2分)

1. 表的长度
2. 元素的类型
3. 元素的存放顺序
4. 元素中各字段的类型

*2-7

(neuDS)要将一个顺序表{a​0​​,a​1​​,……,a​n−1​​}中第i个数据元素a​i​​(0≤i≤n-1)删除，需要移动（ ）个数据元素。 (2分)

1. i
2. n-i-1
3. n-i
4. n-i+1

2-8

用数组表示线性表的优点是（）。 (2分)

1. 便于插入和删除操作
2. 便于随机存取
3. 可以动态地分配存储空间
4. 不需要占用一片相邻的存储空间

2-9

若长度为n的线性表采用顺序存储结构，那么删除它的第i个数据元素之前，需要它一次向前移动（）个数据元素。 (2分)

1. n-i
2. n+i
3. n-i-1
4. n-i+1

2-10

若长度为n的线性表采用顺序结构，在第i个数据元素之前插入一个元素，需要它依次向后移动（）个元素。 (2分)

1. n-i
2. n-i+1
3. n-i-1
4. i

2-11

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

1. n/2
2. (n+1)/2
3. (n-1)/2
4. n

2-12

设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是：(2分)

1. h=t; t->next=h->next;
2. t->next=h->next; h=t;
3. h=t; t->next=h;
4. t->next=h; h=t;

2-13

在单链表中，若p所指的结点不是最后结点，在p之后插入s所指结点，则执行 (2分)

1. s->next=p; p->next=s;
2. s->next=p->next; p=s;
3. s->next=p->next; p->next=s;
4. p->next=s; s->next=p;

2-14

带头结点的单链表h为空的判定条件是： (2分)

1. h == NULL;
2. h->next == NULL;
3. h->next == h;
4. h != NULL;

2-15

将两个结点数都为N且都从小到大有序的单向链表合并成一个从小到大有序的单向链表，那么可能的最少比较次数是： (2分)

1. 1
2. N
3. 2N
4. NlogN

2-16

线性表若采用链式存储结构时，要求内存中可用存储单元的地址 (1分)

1. 必须是连续的
2. 连续或不连续都可以
3. 部分地址必须是连续的
4. 一定是不连续的

2-17

在具有N个结点的单链表中，实现下列哪个操作，其算法的时间复杂度是O(N)？ (2分)

1. 在地址为p的结点之后插入一个结点
2. 删除开始结点
3. 遍历链表和求链表的第i个结点
4. 删除地址为p的结点的后继结点

2-18

对于一个具有N个结点的单链表，在给定值为x的结点后插入一个新结点的时间复杂度为 (2分)

1. O(1)
2. O(N/2)
3. O(N)
4. O(N​2​​)

2-19

链表不具有的特点是： (1分)

1. 插入、删除不需要移动元素
2. 方便随机访问任一元素
3. 不必事先估计存储空间
4. 所需空间与线性长度成正比

2-20

(neuDS)在一个含有n个结点的有序单链表中插入一个新结点，使单链表仍然保持有序的算法的时间复杂度是（ ）。 (2分)

1. O(1)
2. O(log​2​​n)
3. O(n)
4. O(n​2​​)

2-21

将长度为n的单链表连接在长度为m的单链表之后的算法的时间复杂度为（ ）。 (2分)

1. O(1)
2. O(m)
3. O(n)
4. O(n+m)

2-22

(neuDS)在单链表中，增加一个头结点的最终目的是为了( )。 (2分)

1. 使单链表至少有一个结点
2. 方便运算的实现
3. 标识表结点中首结点的位置
4. 说明单链表是线性表的链式存储

2-23

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

1. 直接前驱
2. 自身位置
3. 直接后继
4. 直接后继的后继

2-24

以下关于链式存储结构的叙述中，（）是不正确的。 (2分)

1. 结点除自身信息外还包括指针域，因此存储密度小于顺序存储结构
2. 逻辑上相邻的结点物理上不必邻接
3. 可以通过计算直接确定第i个结点的存储地址
4. 插入、删除运算操作方便，不必移动结点

2-25

线性链表不具有的特点是（）。 (2分)

1. 随机访问
2. 不必事先估计所需存储空间大小
3. 插入与删除时不必移动元素
4. 所需空间与线性长度成正比

2-26

线性表若采用链式存储结构时，要求内存中可用存储单元的地址（）。 (2分)

1. 必须是连续的
2. 部分地址必须是连续的
3. 一定是不连续的
4. 连续或不连续都可以

**2-27

对线性表，在下列情况下应当采用链表表示的是（）。 (2分)

1. 经常需要随机地存取元素
2. 经常需要进行插入和删除操作
3. 表中元素需要占据一片连续的存储空间
4. 表中的元素个数不变

2-28

不带表头附加结点的单链表为空的判断条件是头指针head满足条件（）。 (2分)

1. head==NULL
2. head->next==NULL
3. head->next== head
4. head!=NULL

2-29

可以用带表头附加结点的链表表示线性表，也可以用不带头结点的链表表示线性表，前者最主要的好处是（）。 (2分)

1. 可以加快对表的遍历
2. 使空表和非空表的处理统一
3. 节省存储空间
4. 可以提高存取表元素的速度

2-30

对于一非空的循环单链表，h和p分别指向链表的头、尾结点，则有：(2分)

1. p->next == h
2. p->next == NULL
3. p == NULL
4. p == h

2-31

在双向循环链表结点p之后插入s的语句是： (3分)

1. p->next=s; s->prior=p; p->next->prior=s ; s->next=p->next;
2. p->next->prior=s; p->next=s; s->prior=p; s->next=p->next;
3. s->prior=p; s->next=p->next; p->next=s; p->next->prior=s;
4. s->prior=p; s->next=p->next; p->next->prior=s; p->next=s;

2-32

在双向链表存储结构中，删除p所指的结点，相应语句为：(3分)

1. p->prior=p->prior->prior; p->prior->next=p;
2. p->next->prior=p; p->next=p->next->next;
3. p->prior->next=p->next; p->next->prior=p->prior;
4. p->next=p->prior->prior; p->prior=p->next->next;

2-33

某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用什么存储方式最节省运算时间？ (2分)

1. 单链表
2. 仅有尾指针的单循环链表
3. 仅有头指针的单循环链表
4. 双链表

2-34

若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。则采用哪种存储方式最节省运算时间？ (2分)

1. 单链表
2. 双链表
3. 单循环链表
4. 带头结点的双循环链表

**2-35

将线性表La和Lb头尾连接，要求时间复杂度为O(1)，且占用辅助空间尽量小。应该使用哪种结构？ (2分)

1. 单链表
2. 单循环链表
3. 带尾指针的单循环链表
4. 带头结点的双循环链表

2-36

(neuDS)在链表中若经常要删除表中最后一个结点或在最后一个结点之后插入一个新结点，则宜采用（）存储方式。 (2分)

1. 顺序表
2. 用头指针标识的循环单链表
3. 用尾指针标识的循环单链表
4. 双向链表

2-37

非空的循环单链表head的尾结点（由p所指向）满足（）。 (2分)

1. p->next == NULL
2. p == NULL
3. p->next == head
4. p == head

2-38

在循环双链表的p所指结点之前插入s所指结点的操作是（）。 (2分)

1. p->prior = s; s->next = p; p->prior->next = s; s->prior = p->prior;
2. p->prior = s; p->prior->next = s; s->next = p; s->prior = p->prior;
3. s->next = p; s->prior = p->prior; p->prior = s; p->right->next = s;
4. s->next = p; s->prior = p->prior; p->prior->next = s; p->prior = s;

2-39

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

1. 单链表
2. 给出表头指针的单循环链表
3. 双链表
4. 带表头附加结点的双循环链表

2-40

某线性表最常用的操作是在最后一个结点之后插入一个结点或删除第一个结点，故采用（）存储方式最节省运算时间。 (2分)

1. 单链表
2. 仅有头结点的单循环链表
3. 双链表
4. 仅有尾指针的单循环链表

2-41

在一个长度为n（n>1）的单链表上，设有头和尾两个指针，执行（）操作与链表的长度有关。 (2分)

1. 删除单链表中的第一个元素
2. 删除单链表中的最后一个元素
3. 在单链表第一个元素前插入一个新元素
4. 在单链表最后一个元素后插入一个新元素

2-42

如果对线性表的运算只有4种，即删除第一个元素，删除最后一个元素，在第一个元素前面插入新元素，在最后一个元素的后面插入新元素，则最好使用（）。 (2分)

1. 只有表尾指针没有表头指针的循环单链表
2. 只有表尾指针没有表头指针的非循环双链表
3. 只有表头指针没有表尾指针的循环双链表
4. 既有表头指针也有表尾指针的循环单链表

2-43

如果对线性表的运算只有2种，即删除第一个元素，在最后一个元素的后面插入新元素，则最好使用（）。 (2分)

1. 只有表头指针没有表尾指针的循环单链表
2. 只有表尾指针没有表头指针的循环单链表
3. 非循环双链表
4. 循环双链表

**2-44

在双向循环链表中，在p所指的结点之后插入s指针所指的结点，其操作是（）。 (2分)

1. p->next = s; s->prior = p; (p->next)->prior = s; s->next = p->next;
2. s->prior = p; s->next = p->next; p->next = s; p->next->prior = s;
3. p->next = s; p->next->prior = s; s->prior = p; s->next = p->next;
4. s->prior = p; s->next = p->next; p->next->prior = s; p->next = s;

2-45

带表头附加结点的双向循环链表为空的判断条件是头指针L满足条件（）。 (2分)

1. L= =NULL
2. L->right= =NULL
3. L->left = =NULL
4. L->right= =L

2-46

循环链表的主要优点是（）。 (2分)

1. 不再需要头指针了
2. 已知某个结点的位置后，能够很容易找到它的直接前驱
3. 在进行插入、删除运算时，能更好的保证链表不断开
4. 从表中的任意结点出发都能扫描到整个链表

2-47

已知指针ha和hb分别是两个单链表的头指针，下列算法将这两个链表首尾相连在一起，并形成一个循环链表（即ha的最后一个结点链接hb的第一个结点，hb的最后一个结点指向ha），返回该循环链表的头指针。请将该算法补充完整。 (4分)

typedef struct node{
ElemType data;
    struct node *next;
}LNode;
LNode *merge(LNode *ha, LNode *hb) {
LNode *p=ha;
     if (ha==NULL || hb==NULL) {
cout<<”one or two link lists are empty!”<next!=NULL ) 
           p=p->next;
     p->next=hb;
     while ( p->next!=NULL ) 
           p=p->next;
           __________         
}

1. ha=p->next; return ha;
2. p->next=ha; return ha;
3. ha=p->next; return p;
4. p->next=ha; return p;

2-48

设有一个双向循环链表，每个结点中除有left、data和right三个域外，还增设了一个访问频度域freq，freq 的初值为零。每当链表进行一次查找操作后，被访问结点的频度域值便增1，同时调整链表中结点的次序，使链表按结点频度值非递增有序的次序排列。下列算法是符合上述要求的查找算法，请将该算法补充完整。 (4分)

typedef struct Node{
ElemType  data; 
   struct Node *left;  
   struct Node *right; 
intfreq;          
} DNode;
DNode *locate_DList(DNode *&L, ElemType x)
{ //在表L中查找元素x，查找成功则调整结点频度域值及结点位置，并返回结点地址；
//查找不成功则返回NULL
DNode *p=L, *q;
   if (L==NULL)  return NULL;
   while (p->data!=x && p->right!=L)  p=p->right;
   if (p->data!=x)  return NULL;
   p->freq++; 
   q=p->left;
   while (q!=L && q->freq<=p->freq)  q=q->left;  //查找插入位置
   if (q==L && q->freq<=p->freq) {  //需将p结点插在头结点L前
//将p结点先从链表中摘下来
p->left->right=p->right; 
      p->right->left=p->left;   
               //将p结点插在L结点前
      p->right=L;
      p->left=L->left;
      L->left->right=p;
      L->left=p;
      L=p;
   }
   else if (q!=p->left ) {  //若q不是p的前驱，则需调整结点位置，将p结点插在q结点后
//将p结点先从链表中摘下来
      p->left->right=p->right; 
      p->right->left=p->left;
      ______________ //将p结点插在q结点后         
   }
   return p;
}

1. p->left=q; p->right=q->right;
2. p->left=q; q->right=p;
3. p->left=q; p->right=q->right; q->right->left=p; q->right=p;
4. p->left=q; q->right=p; p->right=q->right; q->right->left=p;

2-49

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

1. 插入、删除操作更加简单
2. 可随机访问
3. 可以省略表头指针或表尾指针
4. 顺序访问相邻结点更加灵活

***2-50

采用多项式的非零项链式存储表示法，如果两个多项式的非零项分别为N​1​​和N​2​​个，最高项指数分别为M​1​​和M​2​​，则实现两个多项式相乘的时间复杂度是：(2分)

1. O(N​1​​×N​2​​)
2. O(M​1​​×M​2​​)
3. O(N​1​​+N​2​​)
4. O(M​1​​+M​2​​)