Algs4-2.2.11-归并的三项改进-复制一次到辅助数组

2.2.11改进。实现2.2.2节所述的对归并排序的三项改进：加快小数组的排序速度，检测数组是否已经有序以及通过在递归中交换参数来避免数组复制。

public class Merge5
{
    private static int subArrayLenTrunONInsertionSort=15;
    public static void sort(Comparable[] a)
    {
        int len=a.length;
        Comparable[] aux=new Comparable[len];
        for(int i=0;i<len;i++)
            aux[i]=a[i];
        sort(a,aux,0,a.length-1);
   }
    private static void sort(Comparable[] a,Comparable[] aux,int lo,int hi)
    {
        if ((hi-lo+1)<=subArrayLenTrunONInsertionSort)
        {
          insertionSort(a,lo,hi);
        }
        else
        {
          int mid=lo+(hi-lo)/2;
          sort(aux,a,lo,mid);
          sort(aux,a,mid+1,hi);
       
          if(!less(aux[mid+1],aux[mid]))
          {
              for(int i=lo;i<=hi;i++)
                  a[i]=aux[i];
              return;
          }
         
          merge(aux,a,lo,mid,hi);
        }
    }

   
    private static void merge(Comparable[] a,Comparable[] aux,int lo,int mid,int hi)
    {
      int i=lo;
      int j=mid+1;
      for(int k=lo;k<=hi;k++)
      {
           if (i>mid) aux[k]=a[j++];
           else if (j>hi) aux[k]=a[i++];
           else if (less(a[j],a[i])) aux[k]=a[j++];
           else                           aux[k]=a[i++];
      }
      }
    private static boolean less(Comparable v,Comparable w)
    { return v.compareTo(w)<0;}
   
    private static void exch(Comparable[] a,int i,int j)
    {
      Comparable t=a[i];
      a[i]=a[j];
      a[j]=t;
    }
   
    private static void insertionSort(Comparable[] a,int lo,int hi)
    {
      for (int i=lo+1;i<=hi;i++)
        for (int j=i;j>lo && less(a[j],a[j-1]);j--)
            exch(a,j,j-1);
    }
   
 public static boolean isSorted(Comparable[] a)
    {
      for(int i=1;i<a.length;i++)
        if(less(a[i],a[i-1])) return false;
      return true;
    }
 
 public static void main(String[] args)
 {
     Integer N=Integer.parseInt(args[0]);
     Comparable[] a=new Comparable[N];
     for(int i=0;i<N;i++)
         a[i]=StdRandom.uniform();
     sort(a);
     StdOut.println("Sorted="+isSorted(a));
 }
}
对于树1的情形，在排序过程的每个递归层交换数组a与aux即可实现aux的0次复制,但对于树2的情形，倒数第二层的结点数据一部分来自在a归并到aux，一部分只能来自a,若倒数第二层所有点的排序数据来自于aux,部分节点无数据可访问，简单的处理方式是在排序前将数组a中的数据复制到aux,这样在倒数第二层就无论是访问a还是aux都有数据可排序。归并在对数组的复制有树深度次对a数组的全部复制。
树1：

树2：

参考：