所有章節答案合集——>傳送門

---

第 2 章線性表

1．選擇題
（ 1）順 序表中 第一個 元 素的存儲 地址 是 100 ，每 個元素的 長度 為 2，則 第 5 個 元 素 的 地 址 是 （ ）。 A． 110 B ． 108 C． 100 D． 120
答案： B
解釋：順序表中的數據連續存儲，所以第 5 個元素的地址為： 100+2*4=108 。

（ 2）在 n 個結點的順序表中，算法的時間復雜度是 O(1) 的操作是（） 。 A ．訪問第 i 個結點（ 1≤ i≤ n）和求第 i 個結點的直接前驅（ 2≤ i≤ n） B ．在第 i 個結點后插入一個新結點（ 1≤ i≤ n） C．刪除第 i 個結點（ 1≤ i≤ n） D ．將 n 個結點從小到大排序
答案： A
解釋： 在順序表中插入一個結點的時間復雜度都是 O(n 2) ，排序的時間復雜度為 O(n 2 ) 或 O(nlog 2n)。順序表是一種隨機存取結構，訪問第 i 個結點和求第 i 個結點的直接前驅都可
以直接通過數組的下標直接定位，時間復雜度是 O(1) 。

（ 3）向一個有 127 個元素的順序表中插入一個新元素并保持原來順序不變， 平均要移動的元素個數為（） 。 A． 8 B ． 63.5 C ． 63 D． 7
答案： B
解釋：平均要移動的元素個數為： n/2 。

（ 4）鏈接存儲的存儲結構所占存儲空間（） 。
A ．分兩部分，一部分存放結點值，另一部分存放表示結點間關系的指針
B ．只有一部分，存放結點值
C．只有一部分，存儲表示結點間關系的指針
D ．分兩部分，一部分存放結點值，另一部分存放結點所占單元數
答案： A

（ 5）線性表若采用鏈式存儲結構時，要求內存中可用存儲單元的地址（） 。
A ．必須是連續的 B．部分地址必須是連續的
C．一定是不連續的 D．連續或不連續都可以
答案： D

（ 6）線性表Ｌ在（）情況下適用于使用鏈式結構實現。
A ．需經常修改Ｌ中的結點值Ｂ．需不斷對Ｌ進行刪除插入
C．Ｌ中含有大量的結點Ｄ．Ｌ中結點結構復雜
答案： B
解釋：鏈表最大的優點在于插入和刪除時不需要移動數據，直接修改指針即可。

（ 7）單鏈表的存儲密度（） 。
A ．大于 1 B ．等于 1 C．小于 1 D．不能確定
答案： C
解釋：存儲密度是指一個結點數據本身所占的存儲空間和整個結點所占的存儲空
間之比，假設單鏈表一個結點本身所占的空間為 D，指針域所占的空間為 N，則存儲密
度為： D/(D+N) ，一定小于 1。

（ 8）將兩個各有 n 個元素的有序表歸并成一個有序表，其最少的比較次數是（） 。
A ． n B ． 2n-1 C ． 2n D ． n-1
答案： A
解釋：當第一個有序表中所有的元素都小于（或大于）第二個表中的元素，只需
要用第二個表中的第一個元素依次與第一個表的元素比較，總計比較 n 次。

（ 9）在一個長度為 n 的順序表中，在第 i 個元素（ 1≤ i≤ n+1 ）之前插入一個新元素時
須向后移動（）個元素。
A ． n-i B ． n-i+1 C． n-i-1 D ． I
答案： B

(10) 線性表 L=(a 1， a2 , an) ，下列說法正確的是（） 。 A ．每個元素都有一個直接前驅和一個直接后繼
B ．線性表中至少有一個元素
C．表中諸元素的排列必須是由小到大或由大到小
D ．除第一個和最后一個元素外，其余每個元素都有一個且僅有一個直接前驅和直接
后繼。
答案： D

(11) 創建一個包括 n 個結點的有序單鏈表的時間復雜度是（） 。 A ． O(1) B ． O(n) C． O(n 2
) D ． O(nlog 2n)
答案： C
解釋：單鏈表創建的時間復雜度是 O(n) ，而要建立一個有序的單鏈表，則每生成一個新結點時需要和已有的結點進行比較，確定合適的插入位置，所以時間復雜度是O(n2) 。

(12) 以下說法錯誤的是（） 。
A ．求表長、定位這兩種運算在采用順序存儲結構時實現的效率不比采用鏈式存儲結
構時實現的效率低
B ．順序存儲的線性表可以隨機存取
C．由于順序存儲要求連續的存儲區域，所以在存儲管理上不夠靈活
D ．線性表的鏈式存儲結構優于順序存儲結構
答案： D
解釋： 鏈式存儲結構和順序存儲結構各有優缺點，有不同的適用場合。

(13) 在單鏈表中，要將 s 所指結點插入到 p 所指結點之后，其語句應為（） 。
A ． s->next=p+1;p->next=s;
B ． (*p).next=s;(*s).next=(*p).next;
C． s->next=p->next;p->next=s->next;
D ． s->next=p->next;p->next=s;
答案： D

(14) 在雙向鏈表存儲結構中，刪除 p 所指的結點時須修改指針（） 。
A ． p->next->prior=p->prior;p->prior->next=p->next;
B ． p->next=p->next->next;p->next->prior=p;
C． p->prior->next=p;p->prior=p->prior->prior;
D ． p->prior=p->next->next;p->next=p->prior->prior;
答案： A

(15) 在雙向循環鏈表中，在 p 指針所指的結點后插入 q 所指向的新結點，其修改指針的
操作是（） 。
A ． p->next=q; q->prior=p;p->next->prior=q;q->next=q;
B ． p->next=q;p->next->prior=q;q->prior=p;q->next=p->next;
C． q->prior=p;q->next=p->next;p->next->prior=q;p->next=q;
D ． q->prior=p;q->next=p->next;p->next=q;p->next->prior=q;
答案： C

2．算法設計題
（ 1）將兩個遞增的有序鏈表合并為一個遞增的有序鏈表。 要求結果鏈表仍使用原來兩個
鏈表的存儲空間 , 不另外占用其它的存儲空間。表中不允許有重復的數據。
[ 題目分析 ]
合并后的新表使用頭指針 Lc 指向， pa 和 pb 分別是鏈表 La 和 Lb 的工作指針 , 初始化為
相應鏈表的第一個結點，從第一個結點開始進行比較，當兩個鏈表 La 和 Lb 均為到達表尾結
點時，依次摘取其中較小者重新鏈接在 Lc 表的最后。如果兩個表中的元素相等，只摘取 La
表中的元素，刪除 Lb 表中的元素，這樣確保合并后表中無重復的元素。當一個表 到達表尾結
點，為空時，將非空表的剩余元素直接鏈接在 Lc 表的最后。
[ 算法描述 ]

void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) {// 合并鏈表 La 和 Lb，合并后的新表使用頭指針 Lc 指向pa=La->next; pb=Lb->next; //pa 和 pb 分別是鏈表 La 和 Lb 的工作指針 , 初始化為相應鏈表的第一個結點Lc=pc=La; // 用 La 的頭結點作為 Lc 的頭結點while(pa && pb) {if(pa->data<pb->data){pc->next=pa;pc=pa;pa=pa->next;} // 取較小者 La 中的元素，將 pa 鏈接在 pc 的后面， pa 指針后移else if(pa->data>pb->data) {pc->next=pb; pc=pb; pb=pb->next;} // 取較小者 Lb 中的元素，將 pb 鏈接在 pc 的后面， pb 指針后移else // 相等時取 La 中的元素，刪除 Lb 中的元素{pc->next=pa;pc=pa;pa=pa->next; q=pb->next;delete pb ;pb =q; } } pc->next=pa?pa:pb; // 插入剩余段delete Lb; // 釋放 Lb 的頭結點 }

---

（ 2）將兩個非遞減的有序鏈表合并為一個非遞增的有序鏈表。 要求結果鏈表仍使用原來
兩個鏈表的存儲空間 , 不另外占用其它的存儲空間。表中允許有重復的數據。

[ 題目分析 ]
合并后的新表使用頭指針 Lc 指向， pa 和 pb 分別是鏈表 La 和 Lb 的工作指針 , 初始化為
相應鏈表的第一個結點，從第一個結點開始進行比較，當兩個鏈表 La 和 Lb 均為到達表尾結
點時，依次摘取其中較小者重新鏈接在 Lc 表的表頭結點之后，如果兩個表中的元素相等，只
摘取 La 表中的元素，保留 Lb 表中的元素。當一個表到達表尾結點，為空時，將非空表的剩
余元素依次摘取，鏈接在 Lc 表的表頭結點之后。
[ 算法描述 ]

void MergeList(LinkList& La, LinkList& Lb, LinkList& Lc, ) {// 合并鏈表 La 和 Lb，合并后的新表使用頭指針 Lc 指向pa=La->next; pb=Lb->next; //pa 和 pb 分別是鏈表 La 和 Lb 的工作指針 , 初始化為相應鏈表的第一個結點Lc=pc=La; // 用 La 的頭結點作為 Lc 的頭結點Lc->next=NULL; while(pa||pb ) {// 只要存在一個非空表，用 q 指向待摘取的元素if(!pa) {q=pb; pb=pb->next;} //La 表為空，用 q 指向 pb ， pb 指針后移else if(!pb) {q=pa; pa=pa->next;} //Lb 表為空，用 q 指向 pa ， pa 指針后移else if(pa->data<=pb->data) {q=pa; pa=pa->next;} // 取較小者（包括相等） La 中的元素，用 q 指向 pa， pa 指針后移else {q=pb; pb=pb->next;} // 取較小者 Lb 中的元素，用 q 指向 pb， pb 指針后移q->next = Lc->next; Lc->next = q; // 將 q 指向的結點插在 Lc 表的表頭結點之后} delete Lb; // 釋放 Lb 的頭結點 }

---

（ 3）已知兩個鏈表 A 和 B 分別表示兩個集合，其元素遞增排列。請設計算法求出 A 與 B
的交集，并存放于 A 鏈表中。
[ 題目分析 ]
只有同時出現在兩集合中的元素才出現在結果表中 , 合并后的新表使用頭指針 Lc 指向。
pa 和 pb 分別是鏈表 La 和 Lb 的工作指針 , 初始化為相應鏈表的第一個結點， 從第一個結點開
始進行比較，當兩個鏈表 La 和 Lb 均為到達表尾結點時，如果兩個表中相等的元素時，摘取
La 表中的元素，刪除 Lb 表中的元素；如果其中一個表中的元素較小時，刪除此表中較小的
元素，此表的工作指針后移。當鏈表 La 和 Lb 有一個到達表尾結點，為空時，依次刪除另一
個非空表中的所有元素。
[ 算法描述 ]

void Mix(LinkList& La, LinkList& Lb, LinkList& Lc) {pa=La->next;pb=Lb->next; pa 和 pb 分別是鏈表 La 和 Lb 的工作指針 , 初始化為相應鏈表的第一個結點Lc=pc=La; // 用 La 的頭結點作為 Lc 的頭結點while(pa&&pb) { if(pa->data==pb- >data) ∥交集并入結果表中。{ pc->next=pa;pc=pa;pa=pa->next; u=pb;pb=pb->next; delete u;} else if(pa->data<pb->data) {u=pa;pa=pa->next; delete u;} else {u=pb; pb=pb->next; delete u;} } while(pa){u=pa; pa=pa->next; delete u;} ∥ 釋放結點空間while(pb) {u=pb; pb=pb->next; delete u ;} ∥釋放結點空間pc- >next=null; ∥置鏈表尾標記。delete Lb; // 釋放 Lb 的頭結點}

---

（ 4）已知兩個鏈表 A 和 B 分別表示兩個集合，其元素遞增排列。請設計算法求出兩個集
合 A 和 B 的差集（即僅由在 A 中出現而不在 B 中出現的元素所構成的集合） ，并以同樣的形
式存儲，同時返回該集合的元素個數。
[ 題目分析 ]
求兩個集合 A 和 B 的差集是指在 A 中刪除 A 和 B 中共有的元素，即刪除鏈表中的相應結
點 , 所以要保存待刪除結點的前驅，使用指針 pre 指向前驅結點。 pa 和 pb 分別是鏈表 La 和
Lb 的工作指針 , 初始化為相應鏈表的第一個結點，從第一個結點開始進行比較，當兩個鏈表
La 和 Lb 均為到達表尾結點時，如果 La 表中的元素小于 Lb 表中的元素， pre 置為 La 表的工
作指針 pa 刪除 Lb 表中的元素；如果其中一個表中的元素較小時，刪除此表中較小的元素，
此表的工作指針后移。 當鏈表 La 和 Lb 有一個為空時， 依次刪除另一個非空表中的所有元素。
[ 算法描述 ]

void Difference （ LinkList& La, LinkList& Lb,int *n ） { ∥差集的結果存儲于單鏈表 La 中， *n 是結果集合中元素個數，調用時為 0 pa=La->next; pb=Lb->next; ∥ pa 和 pb 分別是鏈表 La 和 Lb 的工作指針 , 初始化為相應鏈表的第一個結點pre=La; ∥ pre 為 La 中 pa 所指結點的前驅結點的指針while （ pa&&pb）{if （ pa->data<q->data ） {pre=pa;pa=pa->next;*n++;} ∥ A 鏈表中當前結點指針后移else if （ pa->data>q->data ） q=q->next; ∥ B 鏈表中當前結點指針后移else {pre->next=pa->next; ∥處理 A， B 中元素值相同的結點，應刪除u=pa; pa=pa->next;delete u;} ∥刪除結點} }

---

（ 5）設計算法將一個帶頭結點的單鏈表 A 分解為兩個具有相同結構的鏈表 B、C，其中 B
表的結點為 A 表中值小于零的結點，而 C 表的結點為 A 表中值大于零的結點（鏈表 A 中的元
素為非零整數，要求 B、 C 表利用 A 表的結點） 。 [ 題目分析 ]
B 表的頭結點使用原來 A 表的頭結點，為 C 表新申請一個頭結點。從 A 表的第一個結點
開始，依次取其每個結點 p，判斷結點 p 的值是否小于 0，利用前插法，將小于 0 的結點插入
B 表 , 大于等于 0 的結點插入 C 表。
[ 算法描述 ]

void DisCompose(LinkedList A) { B=A; B->next= NULL; ∥ B 表初始化C=new LNode;∥為 C 申請結點空間C->next=NULL; ∥ C 初始化為空表p=A->next; ∥ p 為工作指針while(p!= NULL) {r=p->next; ∥暫存 p 的后繼if(p->data<0) {p->next=B->next; B- >next=p; } ∥將小于 0 的結點鏈入 B 表 , 前插法else {p->next=C->next; C- >next=p; }∥將大于等于 0 的結點鏈入 C 表 , 前插法p=r; ∥p 指向新的待處理結點。} }

---

（ 6）設計一個算法，通過一趟遍歷在單鏈表中確定值最大的結點。
[ 題目分析 ]
假定第一個結點中數據具有最大值，依次與下一個元素比較，若其小于下一個元素，則
設其下一個元素為最大值，反復進行比較，直到遍歷完該鏈表。
[ 算法描述 ]

ElemType Max (LinkList L ){ if(L->next==NULL) return NULL; pmax=L->next; // 假定第一個結點中數據具有最大值p=L->next->next; while(p != NULL ){// 如果下一個結點存在if(p->data > pmax->data) pmax=p;// 如果 p 的值大于 pmax 的值，則重新賦值p=p->next;// 遍歷鏈表 } return pmax->data;

---

（ 7）設計一個算法，通過遍歷一趟，將鏈表中所有結點的鏈接方向逆轉，仍利用原表的
存儲空間。
[ 題目分析 ]
從首元結點開始，逐個地把鏈表 L 的當前結點 p 插入新的鏈表頭部。
[ 算法描述 ]

void inverse(LinkList &L) {// 逆置帶頭結點的單鏈表 L p=L->next; L->next=NULL; while ( p) { q=p->next; // q 指向 *p 的后繼p->next=L->next; L->next=p; // *p 插入在頭結點之后p = q; } }

---

（ 8）設計一個算法，刪除遞增有序鏈表中值大于 mink 且小于 maxk 的所有元素（ mink
和 maxk 是給定的兩個參數，其值可以和表中的元素相同，也可以不同 ）。 [ 題目分析 ]
分別查找第一個值 >mink 的結點和第一個值 ≥ maxk 的結點，再修改指針，刪除值大于
mink 且小于 maxk 的所有元素。
[ 算法描述 ]

void delete(LinkList &L, int mink, int maxk) { p=L->next; // 首元結點while (p && p->data<=mink) { pre=p; p=p->next; } // 查找第一個值 >mink 的結點if (p) {while (p && p->data<maxk) p=p->next; // 查找第一個值 ≥ maxk 的結點q=pre->next; pre->next=p; // 修改指針while (q!=p) { s=q->next; delete q; q=s; } // 釋放結點空間}//if }

---

（ 9）已知 p 指向雙向循環鏈表中的一個結點， 其結點結構為 data 、prior 、next 三個域，
寫出算法 change§, 交換 p 所指向的結點和它的前綴結點的順序。
[ 題目分析 ]
知道雙向循環鏈表中的一個結點，與前驅交換涉及到四個結點（ p 結點，前驅結點，前
驅的前驅結點，后繼結點）六條鏈。
[ 算法描述 ]
void Exchange （ LinkedList p ） ∥ p 是雙向循環鏈表中的一個結點，本算法將 p 所指結點與其前驅結點交換。

{q=p->llink ；q->llink->rlink=p ；∥ p 的前驅的前驅之后繼為 p p->llink=q->llink ；∥ p 的前驅指向其前驅的前驅。q->rlink=p->rlink ；∥ p 的前驅的后繼為 p 的后繼。q->llink=p ；∥ p 與其前驅交換p->rlink->llink=q ；∥ p 的后繼的前驅指向原 p 的前驅p->rlink=q ；∥ p 的后繼指向其原來的前驅 } ∥算法 exchange 結束。

---

（ 10）已知長度為 n 的線性表 A 采用順序存儲結構，請寫一時間復雜度為 O(n) 、空間復
雜度為 O(1) 的算法，該算法刪除線性表中所有值為 item 的數據元素。
[ 題目分析 ]
在順序存儲的線性表上刪除元素，通常要涉及到一系列元素的移動（刪第 i 個元素，第
i+1 至第 n 個元素要依次前移） 。本題要求刪除線性表中所有值為 item 的數據元素，并未要
求元素間的相對位置不變。因此可以考慮設頭尾兩個指針（ i=1 ， j=n ），從兩端向中間移動，
凡遇到值 item 的數據元素時，直接將右端元素左移至值為 item 的數據元素位置。
[ 算法描述 ]

void Delete （ ElemType A[ ] ， int n ） ∥ A 是有 n 個元素的一維數組，本算法刪除 A 中所有值為 item 的元素。 {i=1 ； j=n ；∥設置數組低、高端指針（下標） 。while （ i<j ）{while （ i<j && A[i]!=item ） i++ ；∥若值不為 item ，左移指針。if （ i<j ） while （ i<j && A[j]==item ） j-- ；∥若右端元素為 item ，指針左移if （ i<j ） A[i++]=A[j--] ； }

---

排版和格式真的很費勁啊啊啊啊， 求贊~

總結

以上是生活随笔為你收集整理的【最详细】数据结构（C语言版 第2版）第二章课后习题答案 严蔚敏 等 编著的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。