這次我們來看一些專項練習的題目，總共是20道選擇題。
分析：因爲輸入的序列是從小到大的，而輸出是從大到小，起泡排序中間不會因爲不存在數據交換而提前結束。而是會完全執行所有的比較，也就是最壞的情況。比較次數 5+4+3+2+1=15。
有一個公式就是n*(n-1)/2。
分析：
A、D肯定是錯的，不用多說。
B選項.只有一次循環滿足某個條件，不調用自己就返回，遞歸纔會一層一層向上返回。
C選項.只陳述了兩種情況，還有其他情況也可以使得遞歸函數結束。1.局部靜態變量是可以控制遞歸函數最終結束的2.可能通過異常來控制遞歸的結束。3.可以利用BIOS或OS的一些數據或一些標準庫的全局值來控制遞歸過程的終止。4.可以把一些數據寫入到BIOS或OS的系統數據區，也可以把數據寫入到一個文件中，以此來控制遞歸函數的終止。
分析：一個遞歸算法必須包括終止條件和它的遞歸部分，而於迭代無關。
分析：
分析：分塊查找法要求將列表組織成以下索引順序結構：
首先將列表分成若干個塊（子表），一般情況下，塊的長度均勻，最後一塊可以不滿。
每塊中元素任意排列，即塊內無序，但塊與塊之間必須有序。
構造一個索引表。其中每個索引項對應一個塊並記錄每塊的起始位置，和每塊中最大關鍵字(或最小關鍵)。索引表按關鍵字有序排列。
分析：答案B
第一次 left=0,right=10,mid=(left+right)/2=5; 索引爲5的爲55。
第二次 left=mid+1=6 ,right=10; mid=(left+right)/2=8;索引爲8的爲93。
分析：因爲數組元素是基本有序，所以快速排序是最慢的，它會退化成冒泡排序。
選擇排序時間複雜度都是O(n^2),堆排序是O(nlogn)。
而基本有序對插入排序是最好的，因爲這樣只需要比較大小，不需要移動，時間複雜度趨近於O(n)。
分析：說法過於絕對，忽略了對角線上面的元素。
分析：題目要求8行5列地址，其實求的就是A[7][4]地址，故位置爲(7*10 + 4)* 4 = 296，即SA+296。
分析：
從(1)到(2):取第一個數25，放到它應該在的位置，25左邊的數都比25小，右邊的都比25大。
從(2)到(3):對25左邊的數列和25右邊的數列{20,15,21},{47,27,68,35,84}分別進行快速排序，同樣先取各數列的第一個數20和47，使其分別放到應該在的位置,即左邊的數都比它小，右邊的都比它大。
從(3)到(4):對{15}，{21}，{35,27}，{68,84}四個子序列進行排序，排序完成。
所以從整個過程分析，這是一個快速排序的過程。
具體分析過程：
1：
左指針：49 （不小於49）
右指針：50, 27（不大於49）
交換（49,27）
27，38, 65, 97, 76, 13, 49, 50
2：
左指針：27, 38, 65（不小於49）
右指針：49（不大於49）
交換（65,49）
27，38, 49, 97, 76, 13, 65, 50
3：
左指針：49（不小於49）
右指針：65， 13（不大於49）
交換（49,13）
27，38, 13, 97, 76, 49, 65, 50
4：
左指針：13， 97（不小於49）
右指針：49（不大於49）
交換（97,49）
27，38, 13, 49, 76, 97, 65, 50
5：
左指針：49（不小於49）
右指針：97， 76， 49（不大於49）
左右指針相等，第一趟結束
{27，38, 13} 49 {76, 97, 65, 50}
分析：題目當中沒有說S的字串不能爲空，所以最後還要再加上一個空串。
字串： n(n+1)/2 + 1
非空子串：n(n+1)/2
非空真子串：n(n+1)/2 - 1
分析：之所以錯是因爲沒有把第一次算進去。
分析：A[ i, j ]在i 行前有 i - 1 行，就有(i - 1) * n 個元素，再加上它是在 j 列，所以就是 (i - 1) * n + j。
分析：j所在的那一列前面有m行，所以j*m，最後再加上前面的i個元素。LOC(a00)+[j*m+i]。
分析：當待排序列已基本有序時，對冒泡排序來說是最好情況，對快速排序來說就是最差情況，而堆排序則最好最差都一樣。時間複雜度爲O(n)。
分析：線性表採用鏈表存儲時，不要求結點所佔空間連續，但是一個結點內部空間必須連續。
分析：
i 0 1 2 3 4 5 6 7 8
s a b a b a a b a b
next[i] -1 0 0 1 2 3 1 2 3
先計算前綴next[i]的值：
next[i]的值主要是看s[i]之前的字符串中重複的子串長度。next[0] = -1，定值。
next[1]是看s[1]之前的字符串“a”中重複的子串長度爲0，故next[1] = 0。
next[2]是看s[2]之前的字符串“ab”中重複的子串長度爲0，故next[2] = 0。
next[3]是看s[3]之前的字符串"aba"中重複的子串長度，s[0]與s[2]重複，長度爲1，故next[3] = 1。
next[4]是看s[4]之前的字符串"abab"中重複的子串長度，s[01]與s[23]重複，長度爲2，故next[4] = 2。
next[5]是看s[5]之前的字符串"ababa"中重複的子串長度，s[012]與s[234]重複，長度爲3，故next[5] = 3。
next[6]是看s[6]之前的字符串"ababaa"中重複的子串長度，s[0]與s[5]重複(因爲多了一個a，無法找到長度爲3的重複字符串這隻能是s[0]與s[5]重複)，長度爲1，故next[6] = 1。
同樣的，求next[7]和next[8]分別爲2和3。
接下來計算nextval[i]的值：
nextval[i]的求解需要比較s中next[i]所在位置的字符是否與s[i]的字符一致，如果一致則用s[next[i]]的nextval的值作爲nextval[i]，如果不一致，則用next[i]做爲nextval[i]。
nextval[0] = -1,和next[0]的值一樣。
nextval[1]，比較s[next[1]] ?= s[1]，next[1] = 0，s[0] = a，而s[1] = b，二者不一致，則nextval[1] = next[1] = 0。
nextval[2]，比較s[next[2]] ?= s[2]，next[2] = 0，s[0] = a，而s[2] = a，二者一致，則nextval[2] = nextval[s[next[2]]] = nextval[s[0]] = -1。
nextval[3]，比較s[next[3]] ?= s[3]，next[3] = 1，s[1] = b，而s[3] = b，二者一致，則nextval[3] = nextval[s[next[3]]] = nextval[s[1]] = 0。
nextval[4]，比較s[next[4]] ?= s[4]，next[4] = 2，s[2] = a，而s[4] = a，二者一致，則nextval[4] = nextval[s[next[4]]] = nextval[s[2]] = -1。
nextval[5]，比較s[next[5]] ?= s[5]，next[5] = 3，s[3] = b，而s[5] = a，二者不一致，則nextval[5] = next[5] = 3。
同樣的求nextval[6]，nextval[7]，nextval[8]分別爲 0 ，-1 ， 0。
這裏是nextval的下標從-1開始，如果從1開始，則其餘各位均＋1，nextval爲0,1,0,1,0,4,1,0,1。
分析：定義二維數組時，不能省略第二維的大小，這是由編譯器原理限制的。所以A錯誤。C少了一個{
分析：
A.數組在堆上創建。
B.sizeof(數組名)就是數組的容量。
C.const指針不可以。
D. char* str = "hello"; sizeof(str)不能計算出內容的容量，只是指針的容量。