如果您发现解答中出现错误、对于没有给出解答的题目你有好的答案或者解答有改进的地方，只要您觉得有问题的地方，您可以通过xiezhenjiang@foxmail.com和我联系，谢谢！

先给出课本中归并排序的C语言实现吧：

 

 
  
  1. #include <stdio.h>   
  2. #include <limits.h>  
  3.  
  4. void merge_sort(int *A, int p, int r);   
  5. void merge(int *A, int p, int q, int r);  
  6.  
  7. int main(int argc, char *argv[])   
  8. {   
  9.     int i;   
  10.     int A[9] = {1,5,7,8,2,4,6,9, -1};   
  11.     merge_sort(A, 0, 8);   
  12.  
  13.     for(i = 0; i < 9; i++)   
  14.     {   
  15.         printf("%d ", A[i]);   
  16.     }   
  17.       
  18.     return 0;   
  19. }  
  20.  
  21. void merge_sort(int *A, int p, int r)   
  22. {   
  23.     int q;   
  24.     if(p &lt; r)   
  25.     {   
  26.         q = (p + r) / 2;   
  27.         merge_sort(A, p, q);   
  28.         merge_sort(A, q+1, r);   
  29.         merge(A, p, q, r);   
  30.     }   
  31. }  
  32.  
  33. void merge(int *A, int p, int q, int r)   
  34. {   
  35.     int length_l = q - p + 1;   
  36.     int length_r = r - q;  
  37.  
  38.     int i,j,k;  
  39.  
  40.     int *L = (int *)malloc( (length_l + 1) * sizeof(int) );   
  41.     int *R = (int *)malloc( (length_r + 1) * sizeof(int) );  
  42.  
  43.     for(i = 0; i < length_l; i++)   
  44.     {   
  45.         L[i] = A[p+i];   
  46.     }  
  47.  
  48.     for(i = 0; i < length_r; i++)   
  49.     {   
  50.         R[i] = A[q+1+i];   
  51.     }  
  52.  
  53.     L[length_l] = INT_MAX;   
  54.     R[length_r] = INT_MAX;  
  55.  
  56.     i = j = 0;  
  57.  
  58.     for(k = p; k <= r; k++)   
  59.     {   
  60.         if(L[i] <= R[j])   
  61.         {   
  62.             A[k] = L[i];   
  63.             i++;   
  64.         }   
  65.         else   
  66.         {   
  67.             A[k] = R[j];   
  68.             j++;   
  69.         }   
  70.     }  
  71.  
  72.     free(L);   
  73.     free(R);   
  74. }  
  75.  
 
  
2.3-1 这个参照课本即可
 
  
2.3-2 直接给出C代码实现
 
  
 
 
  
 
  
  1. void merge2(int *A, int p, int q, int r)   
  2. {   
  3.     int length_l = q - p + 1;   
  4.     int length_r = r - q;  
  5.  
  6.     int i,j,k;  
  7.  
  8.     int *L = (int *)malloc( (length_l) * sizeof(int) );   
  9.     int *R = (int *)malloc( (length_r) * sizeof(int) );  
  10.  
  11.     for(i = 0; i < length_l; i++)   
  12.     {   
  13.         L[i] = A[p+i];   
  14.     }  
  15.  
  16.     for(i = 0; i < length_r; i++)   
  17.     {   
  18.         R[i] = A[q+1+i];   
  19.     }  
  20.  
  21.     i = j = 0;   
  22.     k = p;  
  23.  
  24.     while(i < length_l && j < length_r)   
  25.     {   
  26.         if(L[i] <= R[j])   
  27.         {   
  28.             A[k++] = L[i++];   
  29.         }   
  30.         else   
  31.         {   
  32.             A[k++] = R[j++];   
  33.         }   
  34.     }  
  35.  
  36.     while(i < length_l)   
  37.     {   
  38.         A[k++] = L[i++];   
  39.     }  
  40.  
  41.     while(j < length_r)   
  42.     {   
  43.         A[k++] = R[j++];   
  44.     }  
  45.  
  46.     free(L);   
  47.     free(R);   
  48. }  
  49.  
 
  
2.3-3 略
 
  
2.3-4
 
  
p_w_picpath
 
  
2.3-5二分查找的C代码实现：
 
  
 
 
  
 
  
  1. #include &lt;stdio.h>  
  2.  
  3. int binary_search(int *A, int n, int v);  
  4.  
  5. int main(int argc, char *argv[])   
  6. {   
  7.     int A[9] = {0,1,2,3,4,5,6,7,8};   
  8.     int re;  
  9.  
  10.     re = binary_search(A, 9, -3);  
  11.  
  12.     printf("%d\n", re);   
  13.     return 0;  
  14.  
  15. }  
  16.  
  17. int binary_search(int *A, int n, int v)   
  18. {   
  19.     int low = 0;   
  20.     int high = n;   
  21.     int mid;  
  22.  
  23.     while(low < high)   
  24.     {   
  25.         mid = (low + high) / 2;   
  26.         if(A[mid] == v)   
  27.         {   
  28.             return mid;   
  29.         }   
  30.         else if(A[mid] < v)   
  31.         {   
  32.             low = mid + 1;   
  33.         }   
  34.         else   
  35.         {   
  36.             high = mid - 1;   
  37.         }   
  38.     }  
  39.  
  40.     return -1;   
  41. }  
  42.  
 
  
其递归式为p_w_picpath，所以其最坏时间复杂度为p_w_picpath
 
  
2.3-6 不能，其改善的这是查找中比较的次数，但当它找到了要插入的位置时，其移动数据的次数还是不能减少的，所以时间改善不了。
 
  
2.3-7 伪代码如下：
 
  
 
 
  
 
  
  1. int equal_x(int *A, int n, int x)  
  2.  
  3. {  
  4.  
  5.     merge_sort(A,0, n – 1);  
  6.  
  7.     for(i = 0; i < length(A); i++)  
  8.  
  9.     {  
  10.  
  11.         if(binary_serach(A, n, x – A[i] ) != –1)  
  12.  
  13.         {  
  14.  
  15.               return true;  
  16.  
  17.         }  
  18.  
  19.     }  
  20.  
  21.     return false;  
  22.  
  23. }