快速排序的一种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.总结

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