Algs4-2.2.25-3多向归并排序-最佳的k值

2.2.25多向归并排序。实现一个k向(相对双向而言)归并排序程序。分析你的算法，估计最佳的k值并通过实验验证猜想。

试验50万至5百万个随机double试验后，得出最佳k值为：4~9的数。代码可进一步改进的地方是在k个值中找出最小数的部分，目前采用遍历k个值，第二轮时仍就遍历k个值，没能利用到上一轮的结果。如果将k个值维护在一个类似于最小堆中，性能还可以进一步提升。

public class E2d2d25d3
{
  
    public static double time (Double[] a,int k)
    {
        Stopwatch timer =new Stopwatch();
        E2d2d25d2.sort(a,k);
        return timer.elapsedTime();
    }
   
    public static double timeRandomInput(int N,int k,int T)
    {
        double total =0.0;
        Double[] a=new Double[N];
        for (int t=0;t<T;t++)
        {
            for (int i=0;i<N;i++)
                a[i]=StdRandom.uniform();
            total+=time(a,k);
        }
        return total/T;
    }//end timeRandomInput


   
    public static void main(String[] args)
    {
        int N=Integer.parseInt(args[0]);
        int K=Integer.parseInt(args[1]);
        int T=Integer.parseInt(args[2]);
       
        double minSpeedTimes=Double.MAX_VALUE;
        int minK=0;
       
        for(int k=2;k<=K;k++)
        {
          double t=timeRandomInput(N,k,T);
          StdOut.printf("For %d random Doubles ,k=%d, %d times sort,speed times=%.4f\n",N,k,T,t);
          if (t<minSpeedTimes)
          {
              minSpeedTimes=t;
              minK=k;
          }//end if
        }//end for
        StdOut.println("---------Report-------");
        StdOut.printf("minSpeedTimes=%.4f,k=%d\n",minSpeedTimes,minK);
    }//end main
}//end class


public class E2d2d25d2
{
    private static Comparable[] aux;
    public static void sort(Comparable[] a,int k)
    {
        aux=new Comparable[a.length];
        sort(a,0,a.length-1,k);
    }
   
    public static void sort(Comparable[] a,int lo,int hi,int k)
    {
        if (hi<=lo) return;
        int loNew,hiNew;
        loNew=lo;
        for (int i=0;i<k;i++)
        {
            hiNew=loNew+(hi-loNew)/(k-i);
            sort(a,loNew,hiNew,k);
            loNew=hiNew+1;
        }
        merge(a,lo,hi,k);
    }
   
  
    public static void merge(Comparable[] a,int lo,int hi,int k)
    {
        //
        for (int i=lo;i<=hi;i++)
             aux[i]=a[i];
        //
        Integer[][] b=new Integer[k][2];
        int loNew,hiNew;
        loNew=lo;
        for (int i=0;i<k;i++)
        {
            hiNew=loNew+(hi-loNew)/(k-i);
            b[i][0]=loNew;
            b[i][1]=hiNew;
            loNew=hiNew+1;
        }
        //index=-1 sub array is end
        for(int j=0;j<k;j++)
           if(b[j][0]>b[j][1] || b[j][0]>hi) b[j][0]=-1;
       
        int minIndex=-1;   
        for(int i=lo;i<=hi;i++)
        {
            //find the 1st sub array's top index from k sub array to the minIndex
            for(int j=0;j<k;j++)
                if(b[j][0]>-1) {minIndex=j;break;}
            //find the minValue's index from  elements of k sub array's top elements.
            for(int j=0;j<k;j++)
            {
                if (b[j][0]>-1)
                   if(less(aux[b[j][0]],aux[b[minIndex][0]])) minIndex=j;
            }
            //aux merge to a
            a[i]=aux[b[minIndex][0]];
            //minvalue sub array top--
            b[minIndex][0]++;
            //if sub array is end then set -1
            if(b[minIndex][0]>b[minIndex][1] || b[minIndex][0]>hi) b[minIndex][0]=-1;
        }
      }
  
    private static boolean less(Comparable v,Comparable w)
    { return v.compareTo(w)<0;}

     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)
     {
         int K=Integer.parseInt(args[0]);
         int N=Integer.parseInt(args[1]);
         Comparable[] a=new Comparable[N];
        
         for(int i=0;i<N;i++)
             a[i]=StdRandom.uniform();
         //
        sort(a,K);
        StdOut.printf("isSorted=%s",isSorted(a));
     }
}