算法（Algorithms）第4版 练习 2.3.17

　　public static void sort(Comparable[] a) {
        StdRandom.shuffle(a);//eliminate dependence on input
        StdOut.print("After shuffle:");//for test
        show(a);//for test
        int largest = largest(a);
        exch(a, largest, a.length - 1);
        StdOut.print("After find largest and exchange:");//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)
            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
            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;
        
    }

package com.qiusongde;

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

public class QuickSentinel {

    public static void sort(Comparable[] a) {
        StdRandom.shuffle(a);//eliminate dependence on input
        StdOut.print("After shuffle:");//for test
        show(a);//for test
        int largest = largest(a);//find largest item
        exch(a, largest, a.length - 1);//set sentinel in right bound
        StdOut.print("After find largest and exchange:");//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)
            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
            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 int largest(Comparable[] a) {
        assert a != null;
        assert a.length > 1;
        
        int largestindex = 0;
        for(int i = 1; i < a.length; i++) {
            if(less(a[largestindex], a[i]))
                largestindex = i;
        }
        
        return largestindex;
    }
    
    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);
        sort(a);
        assert isSorted(a);
        show(a);
    }
    
}

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

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

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

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

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

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

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

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

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

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

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

partition(input,   14,   15)
i:15 j:14
j is   14
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 

For 2000 random Doubles 10000 trials
Quick is 2.3s QuickSentinel is 2.3s