<算法书>子数组换位问题

设a[0:n-1]是一个有n个元素的数组，k(0<=k<=n-1)是一个非负整数。 试设计一个算法将子数组a[0:k]与a[k+1,n-1]换位。要求算法在最坏情况下耗时O(n),且只用到O(1)的辅助空间  (来自《计算机算法设计与分析》- 王晓东 - 第三章 - 递归与分治策略 - 课后习题 )

 

初步思考：最简单的方法就是循环(n-k-1)次，将a数组的末尾数字插入到a[0]之前。

具体做法：(1) 首先开辟一个额外空间temp用于存放每一次a数组的末尾数据。

               (2) temp <- a[n-1]

               (3) 将a[0: n-2] 每个数据都依次向后移动一位赋值给a[1: n-1]。

               (4) a[0] <- temp

               (5) 循环执行(2) -(4) 步 (n-k+1)次。

代价分析： 时间代价—— O((n-1)*(n-k+1))  即O(n^2)数量级；空间代价——O(1)

 

我们仔细想想还有没有更快的办法呢？试想一下，如果a[0 : k] 与 a[k+1 : n-1] 正好长度相等，则可以直接一一对应交换即可。 当然，这道题的难点就在于k并不一定是a数组的中间位置。即便如此，但是仍然可以交换：

 

     如果a[0 : k].length< a[k+1 : n-1].length， 则可以将a[0 : k] 与 a[k+1 : n-1] 中最后一部分大小相同的数据交换：

                                              |--------  a[k+1 : n-1] -----------| 

                              a[0:k]       a[k+1 : n-k-2]      a[n-k-1 : n-1]  

     其中  a[0:k] 与  a[n-k-1 : n-1]  长度相同，因此完全可以一一对应交换成：

                              |------  a[0 : n-k-2] -------|

                             a[0:k]        a[k+1 : n-k-2]    a[n-k-1 : n-1] 

     交换完成以后，则a[n-k-1 : n-1] 已经交换到位，而a[0 : n-k-2 ]还需要进一步这样递归交换。

 

源代码如下：

C代码  

1. #include<stdio.h>  
2.   
3. //交换数组的两段大小相等的范围的对应数据  
4. //a[low1] <->a[low2]  a[low1+1]<->a[low2+1]  ... a[high1] <-> a[high2]  
5. void swap(int a[],int low1,int high1,int low2,int high2){  
6.   
7.     int temp;  
8.     while(low1<=high1){  
9.         temp=a[low1];  
10.         a[low1]=a[low2];  
11.         a[low2]=temp;  
12.         low1++;  
13.         low2++;  
14.     }  
15. }  
16.   
17. //利用分治算法， 每次选择最小的数组进行换位  
18. void patition(int a[], int low, int k, int high){  
19.   
20.     if(low<high){  
21.         if((k-low+1)==(high-k))  
22.             swap(a,low,k,k+1,high);  
23.         else if((k-low+1)<(high-k)){  
24.             swap(a,low,k,low+high-k,high);  
25.             patition(a,low,k,low+high-k-1);  
26.         }  
27.         else{  
28.             swap(a,low,high+low-k-1,k+1,high);  
29.             patition(a,high+low-k,k,high);  
30.         }  
31.     }  
32.   
33. }  
34. //测试  
35. int main(){  
36.     int a[]={0,1,2,3,4,5,6,7,8,9,10,11,12,13};  
37.     patition(a,0,4,13);  
38.     for(int i=0;i<14;i++){  
39.         printf("%d  ",a[i]);  
40.     }  
41.     return 0;  
42. }  

         这样的时间复杂度为O(n)，而且交换数据的时候只需要O(1)的额外空间。