1.P24 Insertion-Sort的第一行 for j ← 2 为什么 times是n次而不是n-1？

       for j = 2 一直到 j = n由于j在这一过程中分别会被赋值2，3，4 ... n 到 j = n + 1时才不满足for循环的条件而跳出         循环，所以j = n + 1这个语句还是执行了，因此从2到n+1共 n 次。

2.Insertion Sort 的 C++实现？

 
  
  1. //插入排序，将元素非降序排列(非升序排列只要将while循环条件中  
  2. //的key < arr[j]改成key > arr[j]即可)  
  3.  
  4. template<class T>  
  5. void InsertionSort(T arr[], int n)        
  6. {  
  7.     T key;       //用了保存每次用于比较的值                           
  8.     int j;         //内层循环计数器  
  9. //第一个数已经排好序了，因此i从1开始而不是从0开始  
  10.     for(int i = 1; i < n; ++i){         
  11. //取得准备进行排序的元素  
  12.         key = arr[i];                      
  13. //j 是给key赋值元素的前一个     
  14.         j = i - 1;                           
  15. //这里要注意j的取值，j可以等于0,因为在key < arr[j]中j可以为0  
  16. //表示key一直比较到第一个元素，这里确定j的取值有一个原则就是  
  17.     //key能够和数组的第一个元素进行比较！  
  18.         while(j >= 0 && key < arr[j]){        
  19. //如果前面元素的值大，就让前面的元素值复制到后一个位置。                             
  20.             arr[j + 1] = arr[j];      
  21.                  --j;                        
  22.         }  
  23. //此处是arr[j+1]而非arr[j], 因为在退出循环时，j进行了自减  
  24.         arr[j + 1] = key;                
  25.     }                                      
  26. }  
 
  
 3. SelectionSort的C++实现？
 
  
 
  
  1. template<class T>  
  2. void SelectionSort(T arr[], int n)  
  3. {  
  4.     T tmp;  //用于交换的临时变量  
  5.     //最后一个元素用不着选了，  
  6.     //它必然是最大的，所以i只到n-1  
  7.     for(int i = 0; i < n - 1; ++i){  
  8.         int smallest = i;  
  9.     //选出最小的元素值的下标  
  10.         for(int j = i + 1; j < n; ++j){  
  11.             if(arr[j] < arr[smallest])  
  12.                 smallest = j;  
  13.         }  
  14. //交换最小元素和第i个元素，不能只  
  15. //将arr[smallest]赋值给arr[i],而必须交换  
  16.         tmp = arr[smallest];  
  17.         arr[smallest] = arr[i];  
  18.         arr[i] = tmp;  
  19.     }  
  20. }  
  21.  
 
  
 4.Consider the problem of adding two n-bit binary integers, stored in two n-element       arrays A and B. The sum of the two integers should be stored in binary form in an         (n + 1)-element array C. State the problem formally and write pseudocode for                 adding the two integers.
 
  
伪代码实现：
 
  
BinaryAdd(A, B, C)
 
  
Begin:
 
  
flag = 0;         
 
  
for i = 1  to n
 
  
    key = A[i] + B[i] + flag
 
  
    C[i] = key mod 2
 
  
     if  key > 1
 
  
           flag = 1
 
  
     else
 
  
        flag = 0
 
  
if     flag = 1
 
  
C[n+1] = 1
 
  
---END
 
  
C++实现：
 
  
 
  
  1. void BinaryAdd(int a[], int b[], int* c, int n)  
  2. {  
  3.     int flag = 0; //进位标示符
  4.     for(int i = 0; i < n; ++i){  
  5.         int key = a[i] + b[i] + flag;  
  6.         c[i] = key % 2;  
  7.         if(key > 1){  
  8.             flag = 1;  
  9.         }else{  
  10.             flag = 0;  //这句不能少，少了flag在变成1之后就不能变成0了，一直是进位
  11.         }  
  12.     }  
  13.     if(1 == flag)  
  14.         c[n] = 1;  
  15. } 
 
  
 5.归并排序的内部堆栈是怎样运行的？？？
 
  
6.归并排序的C++实现？
 
  
 
  
  1. //辅助函数：对两个已经排好序的列进行归并  
  2. template<class T>  
  3. void Merge(T arr[], int low, int mid, int high)  
  4. {  
  5.     T *tmpArray = new T[high - low + 1];  
  6.     int k = 0, i = low, j = mid + 1;  
  7.     while(i <= mid && j <= high){  
  8.         if(arr[i] < arr[j]){  
  9.             tmpArray[k++] = arr[i++];   
  10.         }else{  
  11.             tmpArray[k++] = arr[j++];  
  12.         }  
  13.     }  
  14.     while(i <= mid){  
  15.         tmpArray[k++] = arr[i++];   
  16.     }  
  17.     while(j <= high){  
  18.         tmpArray[k++] = arr[j++];  
  19.     }  
  20.     for(int i = 0, k = low; i <= high - low; i++, k++){  
  21.         arr[k] = tmpArray[i];   
  22.     }  
  23.     delete[]tmpArray;  
  24. }  
  25. //归并排序递归实现  
  26. template<class T>  
  27. void MergeSort(T arr[], int low, int high)  
  28. {  
  29.     int mid;  
  30.     if(low < high){  
  31.         mid = (low + high) / 2;  
  32.         MergeSort(arr, low, mid);  
  33.         MergeSort(arr, mid+1, high);  
  34.         Merge(arr, low, mid, high);  
  35.     }  
  36. }  
  37. //带入数组(C/C++数组下标从0开始)  
  38. template<class T>  
  39. void MergeSortArray(T arr[], int n)  
  40. {  
  41.     MergeSort(arr, 0, n - 1);  
  42. }