算法（Algorithms）第4版 练习 2.3.25

 

代码实现：

　　public static void sort(Comparable[] a) {
        StdRandom.shuffle(a);//eliminate dependence on input
        StdOut.print("After shuffle:");//for test
        show(a);//for test
        sort(a, 0, a.length-1);
    }
    
    private static void sort(Comparable[] a, int lo, int hi) {
        
        if(hi <= lo + CUTOFF) {
            if(hi > lo)
                Insertion.sort(a, lo, hi);
            return;
        }
        
        int j = partition(a, lo, hi);
        sort(a, lo, j-1);
        sort(a, j+1, hi);
        
    }

 

单元测试：

package com.qiusongde;

import edu.princeton.cs.algs4.In;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;

public class QuickCutoffInsertion {
    
    private static int CUTOFF = 4;//default value is 8
    
    public static void setCutoff(int cutoff) {
        assert cutoff > 0;
        CUTOFF = cutoff;
    }

    public static void sort(Comparable[] a) {
        StdRandom.shuffle(a);//eliminate dependence on input
        StdOut.print("After shuffle:");//for test
        show(a);//for test
        sort(a, 0, a.length-1);
    }
    
    private static void sort(Comparable[] a, int lo, int hi) {
        
        if(hi <= lo + CUTOFF) {
            if(hi > lo)
                Insertion.sort(a, lo, hi);
            return;
        }
        
        int j = partition(a, lo, hi);
        sort(a, lo, j-1);
        sort(a, j+1, hi);
        
    }
    
    private static int partition(Comparable[] a, int lo, int hi) {
        
        int i = lo;
        int j = hi + 1;
        Comparable v = a[lo];
        
        StdOut.println();//for test
        StdOut.printf("partition(input, %4d, %4d)\n", lo, hi);//for test
        
        while(true) {
            while(less(a[++i], v))//find item larger or equal to v
                if(i == hi)
                    break;
            while(less(v, a[--j]));//not need to worry about j will be out of bound
            
            StdOut.println("i:" + i + " j:" + j);//for test
            
            if(i >= j)//cross
                break;
            
            exch(a, i, j);
            show(a);//for test
        }
        exch(a, lo, j);
        
        StdOut.printf("j is %4d\n", j);//for test
        show(a);//for test
        
        return j;
        
    }
    
    private static void exch(Comparable[] a, int i, int j) {
        
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
        
    }
    
    private static boolean less(Comparable v, Comparable w) {
        
        return v.compareTo(w) < 0;
        
    }
    
    private static void show(Comparable[] a) {
        
        //print the array, on a single line.
        for(int i = 0; i < a.length; i++) {
            StdOut.print(a[i] + " ");
        }
        StdOut.println();
        
    }
    
    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) {
        //Read strings from standard input, sort them, and print.
        String[] a = In.readStrings();
        show(a);//for test
        sort(a);
        assert isSorted(a);
        show(a);//for test
    }
    
}

 

输出结果：

K R A T E L E P U I M Q C X O S 
After shuffle:E R K U M C X A I O E S T P Q L 

partition(input,    0,   15)
i:1 j:10
E E K U M C X A I O R S T P Q L 
i:2 j:7
E E A U M C X K I O R S T P Q L 
i:3 j:5
E E A C M U X K I O R S T P Q L 
i:4 j:3
j is    3
C E A E M U X K I O R S T P Q L 

Insertion.sort(input,    0,    2)
A C E E M U X K I O R S T P Q L 

partition(input,    4,   15)
i:5 j:15
A C E E M L X K I O R S T P Q U 
i:6 j:8
A C E E M L I K X O R S T P Q U 
i:8 j:7
j is    7
A C E E K L I M X O R S T P Q U 

Insertion.sort(input,    4,    6)
A C E E I K L M X O R S T P Q U 

partition(input,    8,   15)
i:15 j:15
j is   15
A C E E I K L M U O R S T P Q X 

partition(input,    8,   14)
i:14 j:14
j is   14
A C E E I K L M Q O R S T P U X 

partition(input,    8,   13)
i:10 j:13
A C E E I K L M Q O P S T R U X 
i:11 j:10
j is   10
A C E E I K L M P O Q S T R U X 

Insertion.sort(input,    8,    9)
A C E E I K L M O P Q S T R U X 

Insertion.sort(input,   11,   13)
A C E E I K L M O P Q R S T U X 
A C E E I K L M O P Q R S T U X 

 

 

性能测试：

package com.qiusongde;

import edu.princeton.cs.algs4.StdOut;

public class Exercise2325 {

    public static void main(String[] args) {
        
        String alg = "QuickCutoffInsertion";
        
        int T = 10;//T trials
        
        for(int N = 1000; N <= 1000000; N *= 10){
            StdOut.println("N:" + N);
            for(int M = 0; M <= 30; M++) {
                QuickCutoffInsertion.setCutoff(M);
                double time = SortCompare.timeRandomInput(alg, N, T);
                StdOut.printf("%8.4f", time);
            }
            StdOut.println();
        }
        
    }

}

 

 

输出结果：

N:1000
  0.0050  0.0030  0.0060  0.0060  0.0060  0.0060  0.0060  0.0030  0.0010  0.0010  0.0030  0.0010  0.0020  0.0010  0.0020  0.0010  0.0000  0.0010  0.0010  0.0000  0.0020  0.0000  0.0020  0.0010  0.0020  0.0000  0.0020  0.0020  0.0000  0.0020  0.0000
N:10000
  0.0200  0.0180  0.0140  0.0140  0.0130  0.0130  0.0140  0.0130  0.0120  0.0150  0.0130  0.0130  0.0100  0.0150  0.0120  0.0130  0.0130  0.0110  0.0120  0.0130  0.0150  0.0110  0.0120  0.0120  0.0150  0.0130  0.0130  0.0140  0.0140  0.0110  0.0150
N:100000
  0.2070  0.2070  0.2010  0.1960  0.1970  0.1970  0.2040  0.2010  0.1800  0.1820  0.1820  0.1780  0.1790  0.1820  0.1800  0.1810  0.1850  0.1860  0.1750  0.1810  0.1810  0.1820  0.1790  0.1830  0.1810  0.1820  0.1840  0.1830  0.1830  0.1840  0.1830
N:1000000
  3.9260  3.9100  3.9300  3.9050  3.8640  3.8250  3.7930  3.8780  3.8090  3.8360  3.7860  3.8530  3.8130  3.7770  3.7800  3.7570  3.8220  3.7800  3.8220  3.7850  3.7970  3.8020  3.8530  3.8340  3.8710  3.7660  3.8080  3.8580  3.8350  3.8890  3.7810