2.2.12次线性的额外空间。用大小M将数组分为N/M块(简单起见，设M是N的约数)。实现一个归并方法，使之所需的额外空间减少到max(M,N/M):(i)可以先将一个块看做一个元素，将块的第一个元素作为块的主键，用选择排序将块排序;(ii)遍历数组，将第一块和第二块归并，完成后将第二块和第三块归并，等等。
答:一个O(N^2)时间复杂度,O(M)空间复杂度的算法。
1)将a划分成N/M个单个长度最长为M的子数组，对每个子数组使用归并排序算法排序。
2)将a划分成N/M个单个长度最长为M子数组，以每个子数组的第一个元素作为排序关键字，使用选择排序算法将各个子数组排序。对N/M个子数组排序,在归并时会因归并的两段已有序而不用再归并。
3)归并子数组1和子数组2,再归并子数组1~2和子数组3,再归并子数组1~3和子数组4，直到归并完子数组1~(N/M-1)和子数组N/M。例如下现的情况(2,20,30)(3,5,8)(4,6,10),归并前两个后为(2,3,5)(8,20,30)(4,6,10),此时若只归并后面两个子组数，归并后的结果是(2,3,5)(4,6,8)(10,20,30)此时是无序的。如果在子数组1,2归并后，再将1,2与子数组3归并，得到的结果(2,3,4)(5,6,8)(10,20,30)才有序，所以此种采用了后段与所有前段归并的方式,也因此形成O(N^2)时间复杂度，但也可以看成是O((N/M)^2)时间复杂度。
4)如果归并的两段的交界值有序，那么跳过本次归并，无序时归并这两段。然后进行下一段与所有前段的归并。归并时先将后段长度为M的子数组复制到辅助数组aux，然后将前段和辅组数组进行归并，两段中的大值从数组a的右边归并到左边。
public class E2d2d12
{
public static void sort(Comparable[] a,int M)
{
int N=a.length;
Comparable[] aux=new Comparable[M];
//sort each block elements, block size is 2*M
for(int lo=0;lo<N;lo=lo+M)
sort(a,aux,lo,lo+M-1);
//sort all blocks with block first element
SelectionSortBlock(a,M);
//Merge
for(int j=1;j<N/M;j++)
{
if (!less(a[j*M],a[j*M-1])) continue;
Merge(a,aux,0,j*M-1,(j+1)*M-1);
}
}
private static void sort(Comparable[] a,Comparable[] aux,int lo,int hi)
{
if (hi<=lo) return;
int mid=lo+(hi-lo)/2;
sort(a,aux,lo,mid);
sort(a,aux,mid+1,hi);
if (!less(a[mid+1],a[mid])) return;
Merge(a,aux,lo,mid,hi);
}
//merge bigger value to the maxIndex of array a.
private static void Merge(Comparable[] a,Comparable[] aux,int lo,int sp,int hi)
{
int M=hi-sp;
//copy right half of array a to aux
for(int i=0;i<M;i++)
aux[i]=a[sp+1+i];
//merge from array aux with left half of a to a
int auxTop=M-1;
int aTop=sp;
for(int k=hi;k>=lo;k--)
{
if(auxTop<0) a[k]=a[aTop--];
else if (aTop<lo) a[k]=aux[auxTop--];
else if(less(aux[auxTop],a[aTop])) a[k]=a[aTop--];
else a[k]=aux[auxTop--];
}
}
private static void SelectionSortBlock(Comparable[] a,int M)
{
int length=a.length;
int minIndex;
for(int i=0;i<length;i=i+M)
{
minIndex=i;
for(int j=i+M;j<length;j=j+M)
if(less(a[j],a[minIndex])) minIndex=j;
exch(a,i,minIndex,M);
}
}
private static boolean less(Comparable v,Comparable w)
{
return v.compareTo(w)<0;
}
private static void exch(Comparable[] a,int i,int j,int length)
{
Comparable t;
for(int index=0;index<length;index++)
{
t=a[i+index];
a[i+index]=a[j+index];
a[j+index]=t;
}
}
public static boolean isSorted(Comparable[] a)
{
int len=a.length;
for(int i=1;i<len;i++)
if (less(a[i],a[i-1])) return false;
return true;
}
public static void main(String[] args)
{
int N=Integer.parseInt(args[0]);
int M=Integer.parseInt(args[1]);
Double[] a=new Double[N];
for(int i=0;i<N;i++)
a[i]=StdRandom.uniform();
sort(a,M);
StdOut.printf("isSorted=%s",isSorted(a));
}
}
问题中的max(M,N/M)没有用到、将第一块和第二块归并，完成后将第二块和第三块归并等等没有用到,块排序对第一块和第二块，第二块对第三块的归并的意义有没有可能是将时间复杂度降底到O(NlgN)的一个前提保证？如果是应该怎么使用？很遗憾,但是下面的内容说明有更好的时间复杂度算法。
