所有章節(jié)答案合集——>傳送門

---

1．選擇題
（ 1）若讓元素 1， 2， 3， 4， 5 依次進(jìn)棧，則出棧次序不可能出現(xiàn)在（）種情況。
A． 5， 4， 3， 2， 1
B． 2， 1， 5， 4， 3
C． 4， 3， 1， 2， 5
D． 2， 3， 5， 4， 1
答案： C
解釋：棧是后進(jìn)先出的線性表，不難發(fā)現(xiàn) C 選項中元素 1 比元素 2 先出棧，違背了棧
的后進(jìn)先出原則，所以不可能出現(xiàn) C 選項所示的情況。

（ 2）若已知一個棧的入棧序列是 1，2，3… n，其輸出序列為 p1，p2，p3 … pn， 若 p1=n ，則 pi 為（）。
A． i
B ． n-i
C ． n-i+1
D ．不確定
答案： C
解釋：棧是后進(jìn)先出的線性表，一個棧的入棧序列是 1， 2， 3，, ， n，而輸出序列的
第一個元素為 n，說明 1，2，3，, ， n 一次性全部進(jìn)棧， 再進(jìn)行輸出， 所以 p1=n ，p2=n-1 ，, ，
pi=n-i+1 。

（ 3）數(shù)組Ｑ［ｎ］用來表示一個循環(huán)隊列，ｆ為當(dāng)前隊列頭元素的前一位置，ｒ為隊尾
元素的位置，假定隊列中元素的個數(shù)小于ｎ，計算隊列中元素個數(shù)的公式為（） 。
A ． r-f
B ． (n+f-r)%n
C ． n+r-f
D ．( n+r-f)%n
答案： D
解釋：對于非循環(huán)隊列，尾指針和頭指針的差值便是隊列的長度，而對于循環(huán)隊列，
差值可能為負(fù)數(shù)， 所以需要將差值加上 MAXSIZE （本題為 n），然后與 MAXSIZE （本題為 n）
求余，即（ n+r-f)%n 。

（ 4）鏈?zhǔn)綏＝Y(jié)點為： (data,link) ， top 指向棧頂 .若想摘除棧頂結(jié)點，并將刪除結(jié)點的值
保存到 x 中 ,則應(yīng)執(zhí)行操作（） 。
A． x=top->data;top=top->link ；
B． top=top->link;x=top->link ；
C． x=top;top=top->link ；
D． x=top->link ；
答案： A
解釋：x=top->data 將結(jié)點的值保存到 x 中，top=top->link 棧頂指針指向棧頂下一結(jié)點，
即摘除棧頂結(jié)點。

（ 5）設(shè)有一個遞歸算法如下

int fact(int n) { //n 大于等于 0 if(n<=0) return 1; else return n*fact(n-1); }

則計算 fact(n) 需要調(diào)用該函數(shù)的次數(shù)為（）。
A． n+1
B． n-1
C． n
D． n+2
答案： A
解釋：特殊值法。設(shè) n=0，易知僅調(diào)用一次 fact(n) 函數(shù)，故選 A 。

（ 6）棧在 （）中有所應(yīng)用。
A．遞歸調(diào)用 B．函數(shù)調(diào)用 C．表達(dá)式求值 D．前三個選項都有
答案： D
解釋：遞歸調(diào)用、函數(shù)調(diào)用、表達(dá)式求值均用到了棧的后進(jìn)先出性質(zhì)。

（ 7）為解決計算機(jī)主機(jī)與打印機(jī)間速度不匹配問題，通常設(shè)一個打印數(shù)據(jù)緩沖區(qū)。主機(jī)
將要輸出的數(shù)據(jù)依次寫入該緩沖區(qū)，而打印機(jī)則依次從該緩沖區(qū)中取出數(shù)據(jù)。該緩沖區(qū)的邏
輯結(jié)構(gòu)應(yīng)該是（） 。
A．隊列 B ．棧 C．線性表 D．有序表
答案： A
解釋：解決緩沖區(qū)問題應(yīng)利用一種先進(jìn)先出的線性表，而隊列正是一種先進(jìn)先出的線性表。

（ 8）設(shè)棧 S 和隊列 Q 的初始狀態(tài)為空，元素 e1、 e2、 e3、 e4、 e5 和 e6 依次進(jìn)入棧 S，
一個元素出棧后即進(jìn)入 Q，若 6 個元素出隊的序列是 e2、 e4、e3、e6、e5 和 e1，則棧 S 的容
量至少應(yīng)該是（ ）。
A． 2 B． 3 C． 4 D． 6
答案： B
解釋：元素出隊的序列是 e2、e4、e3、e6、e5 和 e1 ，可知元素入隊的序列是 e2、e4、
e3、 e6、 e5 和 e1，即元素出棧的序列也是 e2、 e4、 e3、 e6、 e5 和 e1，而元素 e1、 e2、 e3、
e4、 e5 和 e6 依次進(jìn)入棧，易知棧 S 中最多同時存在 3 個元素，故棧 S 的容量至少為 3。

（ 9）若一個棧以向量 V[1…n] 存儲，初始棧頂指針 top 設(shè)為 n+1 ，則元素 x 進(jìn)棧的正確操作是 ( ) 。
A． top++; V[top]=x; B． V[top]=x; top++;
C． top–; V[top]=x; D． V[top]=x; top–;
答案： C
解釋：初始棧頂指針 top 為 n+1 ，說明元素從數(shù)組向量的高端地址進(jìn)棧，又因為元素
存儲在向量空間 V[1…n] 中，所以進(jìn)棧時 top 指針先下移變?yōu)?n，之后將元素 x 存儲在 V[n] 。

（ 10）設(shè)計一個判別表達(dá)式中左，右括號是否配對出現(xiàn)的算法，采用（ ）數(shù)據(jù)結(jié)構(gòu)最佳。
A．線性表的順序存儲結(jié)構(gòu) B．隊列
C. 線性表的鏈?zhǔn)酱鎯Y(jié)構(gòu) D. 棧
答案： D
解釋：利用棧的后進(jìn)先出原則。

（ 11）用鏈接方式存儲的隊列，在進(jìn)行刪除運(yùn)算時（ ）。
A. 僅修改頭指針 B. 僅修改尾指針
C. 頭、尾指針都要修改 D. 頭、尾指針可能都要修改
答案： D
解釋：一般情況下只修改頭指針，但是，當(dāng)刪除的是隊列中最后一個元素時，隊尾指
針也丟失了，因此需對隊尾指針重新賦值。

（ 12）循環(huán)隊列存儲在數(shù)組 A[0…m] 中，則入隊時的操作為（ ）。
A. rear=rear+1 B. rear=(rear+1)%(m-1)
C. rear=(rear+1)%mD. rear=(rear+1)%(m+1)
答案： D
解釋：數(shù)組 A[0…m] 中共含有 m+1 個元素，故在求模運(yùn)算時應(yīng)除以 m+1。

（ 13）最大容量為 n 的循環(huán)隊列， 隊尾指針是 rear ，隊頭是 front ，則隊空的條件是 （ ）。
A. (rear+1)%n==front B. rear==front
C． rear+1==front D. (rear-l)%n==front
答案： B
解 釋 ： 最 大 容 量 為 n 的 循 環(huán) 隊 列 ， 隊 滿 條 件 是 (rear+1)%n==front ， 隊 空 條 件 是rear==front 。

（ 14）棧和隊列的共同點是（ ）。
A. 都是先進(jìn)先出 B. 都是先進(jìn)后出
C. 只允許在端點處插入和刪除元素 D. 沒有共同點
答案： C
解釋：棧只允許在棧頂處進(jìn)行插入和刪除元素，隊列只允許在隊尾插入元素和在隊頭
刪除元素。

（ 15）一個遞歸算法必須包括（ ）。
A. 遞歸部分 B. 終止條件和遞歸部分
C. 迭代部分 D. 終止條件和迭代部分
答案： B

---

2．算法設(shè)計題

（ 1）將編號為 0 和 1 的兩個棧存放于一個數(shù)組空間 V[m] 中，棧底分別處于數(shù)組的兩端。
當(dāng)?shù)?0 號棧的棧頂指針 top[0] 等于 -1 時該棧為空，當(dāng)?shù)?1 號棧的棧頂指針 top[1] 等于 m 時該
棧為空。兩個棧均從兩端向中間增長。試編寫雙棧初始化，判斷棧空、棧滿、進(jìn)棧和出棧等
算法的函數(shù)。雙棧數(shù)據(jù)結(jié)構(gòu)的定義如下：

Typedef struct {int top[2],bot[2]; //棧頂和棧底指針SElemType *V; //棧數(shù)組int m; //棧最大可容納元素個數(shù) }DblStack

[ 題目分析 ]
兩棧共享向量空間，將兩棧棧底設(shè)在向量兩端，初始時，左棧頂指針為 -1 ，右棧頂為 m。
兩棧頂指針相鄰時為棧滿。兩棧頂相向、迎面增長，棧頂指針指向棧頂元素。
[ 算法描述 ]
(1) 棧初始化

int Init() {S.top[0]=-1; S.top[1]=m; return 1; // 初始化成功 }

(2) 入棧操作：

int push(stk S ,int i,int x) ∥ i 為棧號， i=0 表示左棧， i=1 為右棧， x 是入棧元素。入棧成功返回 1，失敗返回 0 {if(i<0||i>1){cout<< “棧號輸入不對 ”<<endl;exit(0);} if(S.top[1]-S.top[0]==1) {cout<< “棧已滿 ”<<endl;return(0);} switch(i) {case 0: S.V[++S.top[0]]=x; return(1); break; case 1: S.V[--S.top[1]]=x; return(1); } } ∥ push

(3) 退棧操作

ElemType pop(stk S,int i) ∥退棧。 i 代表棧號， i=0 時為左棧， i=1 時為右棧。退棧成功時返回退棧元素 ∥否則返回 -1 {if(i<0 || i>1){cout<< “棧號輸入錯誤 ”<<endl ； exit(0);} switch(i) {case 0: if(S.top[0]==-1) {cout<< “棧空 ”<<endl ； return （ -1）； } else return(S.V[S.top[0]--]); case 1: if(S.top[1]==m {cout<< “棧空 ”<<endl; return(-1);} else return(S.V[S.top[1]++]); } ∥ switch } ∥算法結(jié)束

(4) 判斷棧空

int Empty(); {return (S.top[0]==-1 && S.top[1]==m); }

[算法討論 ]
請注意算法中兩棧入棧和退棧時的棧頂指針的計算。左棧是通常意義下的棧，而右棧入
棧操作時，其棧頂指針左移（減 1），退棧時，棧頂指針右移（加 1）。 （ 2）回文是指正讀反讀均相同的字符序列， 如“ abba”和“ abdba ”均是回文， 但“ good ”
不是回文。試寫一個算法判定給定的字符向量是否為回文。 (提示：將一半字符入棧 )
[ 題目分析 ]
將字符串前一半入棧，然后，棧中元素和字符串后一半進(jìn)行比較。即將第一個出棧元素
和后一半串中第一個字符比較，若相等，則再出棧一個元素與后一個字符比較， , ，直至
棧空， 結(jié)論為字符序列是回文。 在出棧元素與串中字符比較不等時， 結(jié)論字符序列不是回文。
[ 算法描述 ]

#define StackSize 100 // 假定預(yù)分配的棧空間最多為 100 個元素 typedef char DataType;// 假定棧元素的數(shù)據(jù)類型為字符 typedef struct {DataType data[StackSize]; int top; }SeqStack; int IsHuiwen( char *t) {// 判斷 t 字符向量是否為回文，若是，返回 1，否則返回 0 SeqStack s; int i , len; char temp; InitStack( &s); len=strlen(t); // 求向量長度for ( i=0; i<len/2; i++)// 將一半字符入棧Push( &s, t[i]); while( !EmptyStack( &s)) {// 每彈出一個字符與相應(yīng)字符比較temp=Pop (&s); if( temp!=S[i]) return 0 ;// 不等則返回 0 else i++; } return 1 ; // 比較完畢均相等則返回 1 }

---

（ 3）設(shè)從鍵盤輸入一整數(shù)的序列： a1, a2, a3， …， an，試編寫算法實現(xiàn)：用棧結(jié)構(gòu)存儲
輸入的整數(shù)，當(dāng) ai≠ -1 時，將 ai 進(jìn)棧；當(dāng) ai=-1 時，輸出棧頂整數(shù)并出棧。算法應(yīng)對異常情
況（入棧滿等）給出相應(yīng)的信息。
[ 算法描述 ]

#define maxsize 棧空間容量 void InOutS(int s[maxsize]) //s 是元素為整數(shù)的棧，本算法進(jìn)行入棧和退棧操作。 {int top=0; //top 為棧頂指針，定義 top=0 時為棧空。for(i=1; i<=n; i++) //n 個整數(shù)序列作處理。18 {cin>>x); // 從鍵盤讀入整數(shù)序列。if(x!=-1) // 讀入的整數(shù)不等于 -1 時入棧。｛ if(top==maxsize-1){cout<< “棧滿” <<endl;exit(0);} else s[++top]=x; //x 入棧。｝else // 讀入的整數(shù)等于 -1 時退棧。{if(top==0){cout<< “棧空” <<endl;exit(0);} else cout<< “出棧元素是” <<s[top--]<<endl;} } }// 算法結(jié)束。

---

（ 4）從鍵盤上輸入一個后綴表達(dá)式，試編寫算法計算表達(dá)式的值。規(guī)定：逆波蘭表達(dá)式
的長度不超過一行，以 $符作為輸入結(jié)束，操作數(shù)之間用空格分隔,操作符只可能有+、?、?、/四種運(yùn)算。例如：23434+2?$ 。 [ 題目分析 ]
逆波蘭表達(dá)式 ( 即后綴表達(dá)式 ) 求值規(guī)則如下：設(shè)立運(yùn)算數(shù)棧 OPND,對表達(dá)式從左到右掃
描 ( 讀入 ) ，當(dāng)表達(dá)式中掃描到數(shù)時， 壓入 OPND棧。 當(dāng)掃描到運(yùn)算符時， 從 OPND退出兩個數(shù)，
進(jìn)行相應(yīng)運(yùn)算，結(jié)果再壓入 OPND 棧。這個過程一直進(jìn)行到讀出表達(dá)式結(jié)束符 $，這時 OPND
棧中只有一個數(shù)，就是結(jié)果。
[ 算法描述 ]

float expr( ) // 從鍵盤輸入逆波蘭表達(dá)式，以‘ $’表示輸入結(jié)束，本算法求逆波蘭式表達(dá)式的值。 ｛ float OPND[30]; // OPND 是操作數(shù)棧。init(OPND); // 兩棧初始化。float num=0.0; // 數(shù)字初始化。cin>>x;//x 是字符型變量。while(x!= ’$’){switch {case ‘0’<=x<=’9’:while((x>= ’0’&&x<=’9’)||x== ’. ’) // 拼數(shù)if(x!= ’. ’) // 處理整數(shù){num=num*10+ （ ord(x)- ord( ‘0’) ） ; cin>>x;} else // 處理小數(shù)部分。{scale=10.0; cin>>x; while(x>= ’0’&&x<=’9’){num=num+(ord(x)- ord( ‘0’)/scale;scale=scale*10; cin>>x; } }//else push(OPND,num); num=0.0;// 數(shù)壓入棧，下個數(shù)初始化case x= ‘ ’:break; // 遇空格，繼續(xù)讀下一個字符。case x= ‘+’:push(OPND,pop(OPND)+pop(OPND));break;case x= ‘ - ’ :x1=pop(OPND);x2=pop(OPND);push(OPND,x2-x1);break; case x= ‘*’:push(OPND,pop(OPND)*pop(OPND));break;case x= ‘ / ’ :x1=pop(OPND);x2=pop(OPND);push(OPND,x2/x1);break; default: // 其它符號不作處理。}// 結(jié)束 switch cin>>x;// 讀入表達(dá)式中下一個字符。}// 結(jié)束 while （ x！ =‘$’）cout<< “后綴表達(dá)式的值為” <<pop(OPND); }// 算法結(jié)束。

[ 算法討論 ] 假設(shè)輸入的后綴表達(dá)式是正確的，未作錯誤檢查。算法中拼數(shù)部分是核心。
若遇到大于等于‘ 0’且小于等于‘ 9’的字符，認(rèn)為是數(shù)。這種字符的序號減去字符‘ 0’的
序號得出數(shù)。對于整數(shù)，每讀入一個數(shù)字字符，前面得到的部分?jǐn)?shù)要乘上 10 再加新讀入的數(shù)
得到新的部分?jǐn)?shù)。當(dāng)讀到小數(shù)點，認(rèn)為數(shù)的整數(shù)部分已完，要接著處理小數(shù)部分。小數(shù)部分
的數(shù)要除以 10 （或 10 的冪數(shù)）變成十分位，百分位，千分位數(shù)等等，與前面部分?jǐn)?shù)相加。
在拼數(shù)過程中，若遇非數(shù)字字符，表示數(shù)已拼完，將數(shù)壓入棧中，并且將變量 num 恢復(fù)為 0，
準(zhǔn)備下一個數(shù)。這時對新讀入的字符進(jìn)入‘ +’、‘ - ’、‘ * ’、‘ / ’及空格的判斷，因此在結(jié)束
處理數(shù)字字符的 case 后，不能加入 break 語句。

---

（ 5）假設(shè)以 I 和 O 分別表示入棧和出棧操作。棧的初態(tài)和終態(tài)均為空，入棧和出棧的操
作序列可表示為僅由 I 和 O 組成的序列， 稱可以操作的序列為合法序列， 否則稱為非法序列。
①下面所示的序列中哪些是合法的？
A. IOIIOIOO B. IOOIOIIO C. IIIOIOIO D. IIIOOIOO
②通過對①的分析， 寫出一個算法， 判定所給的操作序列是否合法。 若合法， 返回 true ，
否則返回 false （假定被判定的操作序列已存入一維數(shù)組中） 。
答案：
① A 和 D 是合法序列， B 和 C 是非法序列。
②設(shè)被判定的操作序列已存入一維數(shù)組 A 中。

int Judge(char A[]) // 判斷字符數(shù)組 A 中的輸入輸出序列是否是合法序列。如是，返回 true ，否則返回 false 。{i=0; //i 為下標(biāo)。j=k=0; //j 和 k 分別為 I 和字母 O 的的個數(shù)。while(A[i]!= ‘ 0’) // 當(dāng)未到字符數(shù)組尾就作。{switch(A[i]) {case ‘I ’: j++; break; // 入棧次數(shù)增 1。case ‘O’: k++; if(k>j){ cout<< “序列非法” <<ednl ； exit(0);} } i++; // 不論 A[i] 是‘ I ’或‘ O’，指針 i 均后移。 } if(j!=k) {cout<< “序列非法” <<endl ； return(false);} else {cout<< “序列合法” <<endl ； return(true);} }// 算法結(jié)束。

[ 算法討論 ] 在入棧出棧序列（即由‘ I ’和‘ O’組成的字符串）的任一位置，入棧次數(shù)
（‘ I ’的個數(shù)）都必須大于等于出棧次數(shù)（即‘ O’的個數(shù)） ，否則視作非法序列，立即給出
信息，退出算法。整個序列（即讀到字符數(shù)組中字符串的結(jié)束標(biāo)記‘ \0 ’），入棧次數(shù)必須等
于出棧次數(shù)（題目中要求棧的初態(tài)和終態(tài)都為空） ，否則視為非法序列。

---

(6）假設(shè)以帶頭結(jié)點的循環(huán)鏈表表示隊列，并且只設(shè)一個指針指向隊尾元素站點 ( 注意不
設(shè)頭指針 ) ，試編寫相應(yīng)的置空隊、判隊空、入隊和出隊等算法。
[ 題目分析 ]
置空隊就是建立一個頭節(jié)點，并把頭尾指針都指向頭節(jié)點，頭節(jié)點是不存放數(shù)據(jù)的；判
隊空就是當(dāng)頭指針等于尾指針時，隊空；入隊時，將新的節(jié)點插入到鏈隊列的尾部，同時將
尾指針指向這個節(jié)點；出隊時，刪除的是隊頭節(jié)點，要注意隊列的長度大于 1 還是等于 1 的
情況，這個時候要注意尾指針的修改，如果等于 1，則要刪除尾指針指向的節(jié)點。
[算法描述 ]

//先定義鏈隊結(jié)構(gòu) : typedef struct queuenode {Datatype data; struct queuenode *next; }QueueNode; // 以上是結(jié)點類型的定義typedef struct {queuenode *rear; }LinkQueue; // 只設(shè)一個指向隊尾元素的指針

(1) 置空隊

void InitQueue( LinkQueue *Q) { // 置空隊：就是使頭結(jié)點成為隊尾元素QueueNode *s; Q->rear = Q->rear->next;// 將隊尾指針指向頭結(jié)點while (Q->rear!=Q->rear->next)// 當(dāng)隊列非空，將隊中元素逐個出隊{s=Q->rear->next; Q->rear->next=s->next; }delete s; }// 回收結(jié)點空間

}
(2) 判隊空

int EmptyQueue( LinkQueue *Q) { // 判隊空。當(dāng)頭結(jié)點的 next 指針指向自己時為空隊return Q->rear->next->next==Q->rear->next; }

(3) 入隊

void EnQueue( LinkQueue *Q, Datatype x) { // 入隊。也就是在尾結(jié)點處插入元素QueueNode *p=new QueueNode;// 申請新結(jié)點p->data=x; p->next=Q->rear->next;// 初始化新結(jié)點并鏈入Q-rear->next=p; Q->rear=p;// 將尾指針移至新結(jié)點 }

(4) 出隊

Datatype DeQueue( LinkQueue *Q) {// 出隊 ,把頭結(jié)點之后的元素摘下Datatype t; QueueNode *p; if(EmptyQueue( Q )) Error("Queue underflow"); p=Q->rear->next->next; //p 指向?qū)⒁碌慕Y(jié)點x=p->data; // 保存結(jié)點中數(shù)據(jù)if (p==Q->rear) {// 當(dāng)隊列中只有一個結(jié)點時， p 結(jié)點出隊后，要將隊尾指針指向頭結(jié)點Q->rear = Q->rear->next; Q->rear->next=p->next; } else Q->rear->next->next=p->next;// 摘下結(jié)點 p delete p;// 釋放被刪結(jié)點return x; }

---

（ 7）假設(shè)以數(shù)組 Q[ m] 存放循環(huán)隊列中的元素 , 同時設(shè)置一個標(biāo)志 tag ，以 tag== 0 和 tag == 1 來區(qū)別在隊頭指針 ( front )和隊尾指針 ( rear )相等時，隊列狀態(tài)為 “空 ”還是 “滿 ”。試編寫與此結(jié)構(gòu)相應(yīng)的插入 (enqueue )和刪除 (dlqueue )算法。
[算法描述 ]
(1) 初始化

SeQueue QueueInit(SeQueue Q) {// 初始化隊列Q.front=Q.rear=0; Q.tag=0; return Q; }

(2) 入隊

SeQueue QueueIn(SeQueue Q,int e) {// 入隊列if((Q.tag==1) && (Q.rear==Q.front)) cout<<" 隊列已滿 "<<endl; else {Q.rear=(Q.rear+1) % m; Q.data[Q.rear]=e; if(Q.tag==0) Q.tag=1; // 隊列已不空} return Q; }

(3) 出隊

ElemType QueueOut(SeQueue Q) {// 出隊列if(Q.tag==0) { cout<<" 隊列為空 "<<endl; exit(0);} else {Q.front=(Q.front+1) % m; e=Q.data[Q.front]; if(Q.front==Q.rear) Q.tag=0; // 空隊列} return(e); }

---

(8 ）如果允許在循環(huán)隊列的兩端都可以進(jìn)行插入和刪除操作。要求：
① 寫出循環(huán)隊列的類型定義；
② 寫出“從隊尾刪除”和“從隊頭插入”的算法。
[ 題目分析 ] 用一維數(shù)組 v[0…M-1] 實現(xiàn)循環(huán)隊列，其中 M 是隊列長度。設(shè)隊頭指針front 和隊尾指針 rear ，約定 front 指向隊頭元素的前一位置， rear 指向隊尾元素。定義front=rear 時為隊空，(rear+1)%m=front 為隊滿。約定隊頭端入隊向下標(biāo)小的方向發(fā)展，隊尾端入隊向下標(biāo)大的方向發(fā)展。
[ 算法描述 ]
①

#define M 隊列可能達(dá)到的最大長度 typedef struct {elemtp data[M]; int front,rear; }cycqueue;

②

elemtp delqueue ( cycqueue Q) //Q 是如上定義的循環(huán)隊列，本算法實現(xiàn)從隊尾刪除，若刪除成功，返回被刪除元素， 否則給出出錯信息。 {if (Q.front==Q.rear) {cout<<" 隊列空 "<<endl; exit(0);} Q.rear=(Q.rear-1+M)%M; // 修改隊尾指針。return(Q.data[(Q.rear+1+M)%M]); // 返回出隊元素。 }// 從隊尾刪除算法結(jié)束 void enqueue (cycqueue Q, elemtp x) // Q 是順序存儲的循環(huán)隊列，本算法實現(xiàn)“從隊頭插入”元素 x。 {if(Q.rear==(Q.front-1+M)%M) {cout<<" 隊滿 "<<endl; exit(0);) Q.data[Q.front]=x; //x 入隊列Q.front=(Q.front-1+M)%M; // 修改隊頭指針。 }// 結(jié)束從隊頭插入算法。

---

（ 9）已知 Ackermann 函數(shù)定義如下 :
① 寫出計算 Ack(m,n) 的遞歸算法，并根據(jù)此算法給出出 Ack(2,1) 的計算過程。
② 寫出計算 Ack(m,n) 的非遞歸算法。
[ 算法描述 ]

int Ack(int m,n) {if (m==0) return(n+1);else if(m!=0&&n==0) return(Ack(m-1,1)); else return(Ack(m-1,Ack(m,m-1)); }// 算法結(jié)束

① Ack(2,1) 的計算過程
Ack(2,1)=Ack(1,Ack(2,0)) // 因 m<>0,n<>0 而得
=Ack(1,Ack(1,1)) // 因 m<>0,n=0 而得
=Ack(1,Ack(0,Ack(1,0))) // 因 m<>0,n<>0 而得
=Ack(1,Ack(0,Ack(0,1))) // 因 m<>0,n=0 而得
=Ack(1,Ack(0,2)) // 因 m=0 而得
=Ack(1,3) // 因 m=0 而得
=Ack(0,Ack(1,2)) // 因 m<>0,n<>0 而得
= Ack(0,Ack(0,Ack(1,1))) // 因 m<>0,n<>0 而得
= Ack(0,Ack(0,Ack(0,Ack(1,0)))) // 因 m<>0,n<>0 而得
= Ack(0,Ack(0,Ack(0,Ack(0,1)))) // 因 m<>0,n=0 而得
= Ack(0,Ack(0,Ack(0,2))) // 因 m=0 而得
= Ack(0,Ack(0,3)) // 因 m=0 而得
= Ack(0,4) // 因 n=0 而得
=5 // 因 n=0 而得
②

int Ackerman(int m, int n) {int akm[M][N];int i,j; for(j=0;j<N;j++) akm[0][j]=j+1; for(i=1;i<m;i++) {akm[i][0]=akm[i-1][1]; for(j=1;j<N;j++) akm[i][j]=akm[i-1][akm[i][j-1]]; } return(akm[m][n]); }// 算法結(jié)束

---

（ 10）已知 f 為單鏈表的表頭指針 , 鏈表中存儲的都是整型數(shù)據(jù)，試寫出實現(xiàn)下列運(yùn)算
的遞歸算法：
①求鏈表中的最大整數(shù)；
②求鏈表的結(jié)點個數(shù)；
③求所有整數(shù)的平均值。
[算法描述 ]
①

int GetMax(LinkList p) { if(!p->next) return p->data; else { int max=GetMax(p->next); return p->data>=max ? p->data:max; } }

②

int GetLength(LinkList p) { if(!p->next) return 1; else { return GetLength(p->next)+1; } }

③

double GetAverage(LinkList p , int n) { if(!p->next) return p->data; else { double ave=GetAverage(p->next,n-1); return (ave*(n-1)+p->data)/n; } }

---

排版和格式真的很費(fèi)勁啊啊啊啊， 求贊~

總結(jié)

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

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。