Natural Merge Sort(自然归并排序)

// Natural merge sort program in the textbook

public class NaturalMergeSortProgram {
    
    public static void main(String[] args) 
    {
        int a[] = new int[10000000];
        int b[] = new int[a.length];
        for (int i = 0; i < a.length; i++)
            a[i] = (int)(1+Math.random()*(100-0+1));
        long starTime=System.currentTimeMillis();
        NaturalMergeSort(a, b);
        long endTime=System.currentTimeMillis();
        long Time = endTime - starTime;
        System.out.println("executing time: "+Time+"(ms)");
        /*for (int i = 0; i < b.length; i++)
        {    if (i % 20 == 0)
                System.out.println();
            System.out.print(a[i]+" ");
        }*/
    }

    public static void NaturalMergeSort(int a[], int b[])
    {    // merge array a into b and then b into a until sorted
        while (!MergeRuns(a, b) & !MergeRuns(b, a));
    }
    
    public static boolean MergeRuns(int a[], int b[])
    {
        int i = 0, k = 0;
        int n = a.length;
        boolean asc = true; 
        int x;
        while (i < n)
        {
            k = i;
            do 
                x = a[i++];
            while (i < n && x <= a[i]);        // elements are increasing
            
            while (i < n && x >= a[i])        // elements are decreasing
                x = a[i++];                    
            merge(a, b, k , i-1, asc);
            asc = !asc;
        }
        return k == 0;
    }
    
    
    public static void merge(int a[], int b[], int low, int high, boolean asc)
    {    // merge a[low:high] into b[low:high]
        int k = asc ? low : high;
        int c = asc ? 1 : -1;
        int i = low, j = high;
        while (i <= j)
        {
            if (a[i] <= a[j])
                b[k] = a[i++];
            else 
                b[k] = a[j--];
            k += c;
        }
    }

}

// My own natural merge sort program

public class MyNaturalMergeSort {
    
    public static void main(String args[]) {
        int a[] = new int[10000000];
        int b[] = new int[a.length];
        for (int i = 0; i < a.length; i++)
            a[i] = (int)(1+Math.random()*(100-0+1));
        long starTime=System.currentTimeMillis();
        while (!NaturalMergeSort(a, b) & !NaturalMergeSort(b, a));
        long endTime=System.currentTimeMillis();
        long Time = endTime - starTime;
        System.out.println("executing time: "+Time+"(ms)");
        /*for (int i = 0; i < a.length; i++)
            System.out.print(a[i]+" ");
        System.out.println();
        */
    }
    
    public static boolean NaturalMergeSort(int x[], int y[]) {
        // find the two adjacent natural increasing arrays x[l:m] and x[m+1:r],
        // then merge them into y[l:r] using function merge()
        int i, l, m = 0, r;
        for (i = 0; i < x.length; i++)
        {    l = i;
            while ((i < x.length-1) && (x[i] <= x[i+1]))    // get x[l:m]
                i++;
            m = i++;
            if (m == x.length-1)        // the whole array is sorted
                return true;
            while ((i < x.length-1) && (x[i] <= x[i+1]))    // get x[m+1:r]
                i++;
            r = i;
            merge(x, y, l, m, r);
        }
        return false;    // the whole array is not yet sorted
    }
    
    public static void merge(int x[], int y[], int l, int m, int r) {
        // merge x[l:m] and x[m+1:r] into y[l:r]
        int i = l, 
            j = m+1,
            k = l;
        while ((i <= m) && (j <= r))
            if (x[i] <= x[j])
                y[k++] = x[i++];
            else
                y[k++] = x[j++];
        while (k <= r)
            if (i > m)    // elements in x[l:m] are all merged into array y[] 
                y[k++] = x[j++];
            else 
                y[k++] = x[i++];
                
    }
}