快速排序的一种Java实现

快速排序是笔试和面试中很常见的一个考点。
快速排序是冒泡排序的升级版，时间复杂度比冒泡排序要小得多。除此之外，快速排序是不稳定的，冒泡排序是稳定的。

1.原理

（1）在数据集之中，选择一个元素作为"基准"（pivot）。
（2）所有小于"基准"的元素，都移到"基准"的左边；所有大于"基准"的元素，都移到"基准"的右边。
（3）对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。
注：此处参考了阮一峰老师的文章。

2.对原理的解读

（1）基准是可以任选的，可以从一个数组的开头选，也可以从中间选，当然也可以从最后选。总之，任意选都可以。个人认为将数组开头的元素作为基准比较容易理解。
（2）「二分法」的思想，也就是「分而治之」。
（3）采用递归实现。

3.Java实现

package com.primeton.sort;

import java.util.Arrays;
/**
 * 快速排序类
 * @author Chen
 *
 */
public class QuickSort {

    private static int num = 0;    //比较次数，在显示方法中使用
    
    /**
     * 每轮排序结束后都显示一次
     * @param a 
     */
    public static void show(int[] a){
        num++;
        System.out.println("第"+num+"次： "+Arrays.toString(a));
    }
    
    /**
     * 重载
     * @param a
     */
    public static void quickSort(int[] a){
        quickSort(a,0,a.length-1);
    }
    
    /**
     * 快速排序
     * @param a
     * @param base        基准点
     * @param arrEle    数组元素
     */
    public static void quickSort(int[] a,int base,int arrEle){
        int i, j;  
        i = base;  
        j = arrEle;
        
        if ((a == null) || (a.length == 0)){
            return;  
        }
        if(base<0 || arrEle < 0 || arrEle<base){
            return;
        }
          
        while (i < j) {//查找基准点下标  
            while (i < j && a[i] <= a[j]){ // 以数组下标base的数据为基准，从右侧开始扫描
                j--;  
            }
            if (i < j) { // 右侧扫描，找出第一个比base小的，交换位置  
                int temp = a[i];  
                a[i] = a[j];  
                a[j] = temp;  
            }  
            while (i < j && a[i] < a[j]){  // 左侧扫描（此时a[j]中存储着base值）
                i++; 
            }
            if (i < j) { // 找出第一个比base大的，交换位置  
                int temp = a[i];  
                a[i] = a[j];  
                a[j] = temp;  
            }  
        }  
        show(a);
        
        if (i - base > 1) { // 递归调用，把base前面的完成排序  
            quickSort(a, 0, i - 1);  
        }  
        if (arrEle - j > 1) {  
            quickSort(a, j + 1, arrEle); // 递归调用，把base后面的完成排序  
        }  
        
    }
    
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a={2,4,1,3};
        QuickSort.quickSort(a);
        System.out.println("最终结果："+Arrays.toString(a));
    }

}

4.结果

      原始数组：[2,4,1,3]

第1次： [1, 2, 4, 3]
第2次： [1, 2, 3, 4]
最终结果：[1, 2, 3, 4]

5.总结

快速排序采用了「二分法」的思想，采用递归实现。相比冒泡排序，时间复杂度要小很多。