數據結構鏈表練習題

判斷題：

1.對於順序存儲的長度為N的線性表，訪問結點和增加結點的時間復雜度分別對應為O(1)和O(N)。T

2.若某線性表最常用的操作是存取任一指定序號的元素和在最后進行插入和刪除運算，則利用順序表存儲最節省時間。T

3.在具有N個結點的單鏈表中，訪問結點和增加結點的時間復雜度分別對應為O(1)和O(N)。F

4.對於順序存儲的長度為N的線性表，刪除第一個元素和插入最后一個元素的時間復雜度分別對應為O(1)和O(N)。F

5.若用鏈表來表示一個線性表，則表中元素的地址一定是連續的。F

6.在順序表中邏輯上相鄰的元素，其對應的物理位置也是相鄰的。T

7.順序存儲的線性表不支持隨機存取。F

8.在順序表上進行插入、刪除操作時需要移動元素的個數與待插入或待刪除元素的位置無關。F

9.在線性表的順序存儲結構中可實現快速的隨機存取，而在鏈式存儲結構中則只能進行順序存取。T

10.)單鏈表不是一種隨機存取的存儲結構。

單選題：

1.

在雙向循環鏈表中，在p所指的結點之后插入s指針所指的結點，其操作是（）。 

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.

線性表采用鏈式存儲時，其地址（）。 

1. 必須是連續的
2. 一定是不連續的
3. 部分地址必須是連續的
4. 連續與否均可以

3.

線性表的順序存儲結構是一種( ) 

1. 隨機存取的存儲結構
2. 順序存取的存儲結構
3. 索引存取的存儲結構
4. 散列存取的存儲結構

4.

一個順序表所占用的存儲空間大小與( )無關。

1. 表的長度
2. 元素的類型
3. 元素的存放順序
4. 元素中各字段的類型

5.

假設在順序表{A0,A1,...,An-1}中，每一個數據元素所占用的存儲單元的數目為4，且第0個數據元素A0的存儲地址為100，由第7個數據元素A7的存儲地址是( )。 

1. 106
2. 107
3. 124
4. 128

6.

在鏈表中若經常要刪除表中最后一個結點或在最后一個結點之后插入一個新結點，則宜采用（）存儲方式。 

1. 順序表
2. 用頭指針標識的循環單鏈表
3. 用尾指針標識的循環單鏈表
4. 雙向鏈表

7.

要將一個順序表{a​0​​,a​1​​,……,a​n−1​​}中第i個數據元素a​i​​(0≤i≤n-1)刪除，需要移動（ ）個數據元素。

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

8.

對於下圖2.29所示的單鏈表，下列表達式值為真的是( )。 

1. head.getNext().getData()=='C'
2. P2.getNext()==null
3. head.getData()=='B'
4. P1.getData()=='D’

9.

一個一維數組Ｍ，下標的范圍是０到９，每個數組元素用相鄰的５個字節存儲。存儲器按字節編址，設存儲數組元素Ｍ[０]的第一個字節的地址是100，則Ｍ[4]的第一個字節的地址是。 (2分)

1. 113
2. 115
3. 125
4. 120

10.

鏈式存儲結構的最大優點是（ ）。

1. 便於隨機存取
2. 存儲密度高
3. 便於進行插入和刪除操作
4. 無需預分配空間

11.

在單鏈表中，增加一個頭結點的最終目的是為了( )。 

1. 使單鏈表至少有一個結點
2. 方便運算的實現
3. 標識表結點中首結點的位置
4. 說明單鏈表是線性表的鏈式存儲

12.

已知指針ha和hb分別是兩個單鏈表的頭指針，下列算法將這兩個鏈表首尾相連在一起，並形成一個循環鏈表（即ha的最后一個結點鏈接hb的第一個結點，hb的最后一個結點指向ha），返回該循環鏈表的頭指針。請將該算法補充完整。

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;

13.

已知單鏈表中的元素以值遞增有序排列，下列算法刪除單鏈表中所有值相同的元素，同時釋放被刪結點空間。請將該算法補充完整。 

typedef struct node{
ElemType data;
    struct node *next;
}LNode;
void delete_equal(LNode *h){
LNode *p=h, *q;
     if (h==NULL)  return;
    while (p->next!=NULL) {
        q=p->next;
        if (p->data!=q->data) 
             p=q;
        else  //相鄰兩元素值相等，則循環刪除后繼等值結點
             while (q!=NULL && q->data==p->data) {
             __________________________     
             }
    }
}

1. p->next=q->next; delete q;
2. q->next=p->next; delete q; q=p->next;
3. p->next=q->next; delete q; q= p->next;
4. p->next=q->next; delete q; q=p;

14.

帶表頭附加結點的單鏈表head為空的判斷條件是（）。 

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

15.

非空的循環單鏈表head的尾結點（由p所指向）滿足（）。

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

16.

在循環雙鏈表的p所指結點之前插入s所指結點的操作是（）。 

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;

17.

若某表最常用的操作是在最后一個結點之后插入一個結點或刪除最后一個結點，則采用（）存儲方式最節省運算時間。

1. 單鏈表
2. 給出表頭指針的單循環鏈表
3. 雙鏈表
4. 帶表頭附加結點的雙循環鏈表

18.

某線性表最常用的操作是在最后一個結點之后插入一個結點或刪除第一個結點，故采用（）存儲方式最節省運算時間。 

1. 單鏈表
2. 僅有頭結點的單循環鏈表
3. 雙鏈表
4. 僅有尾指針的單循環鏈表

19.

在一個長度為n（n>1）的單鏈表上，設有頭和尾兩個指針，執行（）操作與鏈表的長度有關。 

1. 刪除單鏈表中的第一個元素
2. 刪除單鏈表中的最后一個元素
3. 在單鏈表第一個元素前插入一個新元素
4. 在單鏈表最后一個元素后插入一個新元素

20.

如果對線性表的運算只有4種，即刪除第一個元素，刪除最后一個元素，在第一個元素前面插入新元素，在最后一個元素的后面插入新元素，則最好使用（）。 

1. 只有表尾指針沒有表頭指針的循環單鏈表
2. 只有表尾指針沒有表頭指針的非循環雙鏈表
3. 只有表頭指針沒有表尾指針的循環雙鏈表
4. 既有表頭指針也有表尾指針的循環單鏈表