Java-快速排序

一、快速排序的原理

使用分治算法进行快速排序，以最后一个元素为标识，然后从头开始遍历，把比这个标识小的元素全部放在左边，把比这个标识大的元素全部放在右边，最后就用这个标识将数组分成了两个部分，然后再分别对标识的前后部分的数组继续进行排序，如此下去就能得到排好序的数组。

二、快速排序的伪代码实现

QUICKSORT(A, p, r)  
 if p < r  
    then q ← PARTITION(A, p, r)  
         QUICKSORT(A, p, q - 1)  
         QUICKSORT(A, q + 1, r)  
PARTITION(A, p, r)  
  x ← A[r]  
  i ← p - 1  
  for j ← p to r - 1  
       do if A[j] ≤ x  
             then i ← i + 1  
             exchange A[i] ←→ A[j]  
  exchange A[i + 1] ←→ A[r]  
  return i + 1  

三、快速排序的Java代码实现

import java.util.Comparator;


public class QuickSort {
    
    public static <T> void quickSort(T[] t, int p, int r, Comparator<? super T> c){
        if(p < r-1){
            int q = partition(t, p, r, c);
            quickSort(t, p, q, c);
            quickSort(t, q+1, r, c);
            
        }
    }
    public static <T> int partition(T[] t, int p, int r, Comparator<? super T> c){
        T x = t[r-1];
        int i = p-1;
        for(int j = p; j < r-1; j ++){
            if(c.compare(t[j], x) < 0){
                i = i + 1;
                T temp = t[i];
                t[i] = t[j];
                t[j] = temp;
            }
        }
        T temp = t[i+1];
        t[i+1] = t[r-1];
        t[r-1] = temp;
        return i + 1;        
    }
    
    public static <T> void quickSort(T[] t, Comparator<? super T> c){
        quickSort(t, 0, t.length, c);
    }
    
    public static void main(String[] args){
        //在这里进行代码测试
        Integer[] ints = new Integer[]{2, 0, 5, 23, 1, 4, 8, 56, 19};
        quickSort(ints, new Comparator<Integer>(){
            public int compare(Integer o1, Integer o2){
                return o1-o2;
            }
        }); 
        
        for(int i = 0; i < ints.length; i ++){
            System.out.print(ints[i] + " ");
        }
    }
}

运行结果：

0 1 2 4 5 8 19 23 56