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!”<<endl;
          return NULL;
     }
     while ( p->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​​)