JAVA数据结构--快速排序

快排概念

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序个项目要（大O符号）次比较。在最坏状况下则需要次比较，但这种状况并不常见。事实上，快速排序通常明显比其他算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

实现思想

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。

步骤为：

1. 从数列中挑出一个元素，称为"基准"（pivot），
2. 重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

借用下啊哈算法的图：

i和j分别为左哨兵和右哨兵，这里枢纽元定为6，然后分别从左往右（i++）和右往左（j--）开始遍历

左哨兵查找比6大的元素，右哨兵查找比6小的元素

第一次交换结果

第二次交换结果

相遇后直接与枢纽元交换

然后再递归排序就行

---

快排核心算法代码

 public static <T extends Comparable<? super T>> void quicksort(T[] a,int left,int right) {
         /*
          * 当数组不小于3时，才推荐使用快排
          * */
         if(left+CUTOFF<=right)
         {
             //取出枢纽元，枢纽元的位置为right-1
             T privot=median3(a, left, right);
 
             int i=left,j=right-1;
             for(;;)
             {
                 while(a[++i].compareTo(privot)<0) {}//i哨兵向右遍历
                 while(a[--j].compareTo(privot)>0) {}//j哨兵向左遍历
                 if(i<j)
                     swapReferences(a, i, j);
                 else
                     break;
             }
             /*
              * for循环终止条件为i和j相遇，此时再将枢纽元归位
              * */
             swapReferences(a, i, right-1);
 
             quicksort(a, left, i-1);//对左半部进行递归
             quicksort(a, i+1, right);//对右半部进行递归
         }
         else
         {}
     }

全部代码实现

 public class MyQuickSort {
     private static final int CUTOFF=3;
     public static <T extends Comparable<? super T>> void quicksort(T[] a) {
         quicksort(a,0,a.length-1);
     }
     public static <T extends Comparable<? super T>> void quicksort(T[] a,int left,int right) {
         /*
          * 当数组不小于3时，才推荐使用快排
          * */
         if(left+CUTOFF<=right)
         {
             //取出枢纽元，枢纽元的位置为right-1
             T privot=median3(a, left, right);
 
             int i=left,j=right-1;
             for(;;)
             {
                 while(a[++i].compareTo(privot)<0) {}//i哨兵向右遍历
                 while(a[--j].compareTo(privot)>0) {}//j哨兵向左遍历
                 if(i<j)
                     swapReferences(a, i, j);
                 else
                     break;
             }
             /*
              * for循环终止条件为i和j相遇，此时再将枢纽元归位
              * */
             swapReferences(a, i, right-1);
 
             quicksort(a, left, i-1);//对左半部进行递归
             quicksort(a, i+1, right);//对右半部进行递归
         }
         else
         {}
     }
     /*
      * 数组中数值交换
      * */
     public static <T> void swapReferences(T[] a,int index1,int index2) {
         T tmp=a[index1];
         a[index1]=a[index2];
         a[index2]=tmp;
     }
     /*
      * 确定枢纽元，枢纽元的位置放在right-1位置
      * */
     private static <T extends Comparable<? super T>> T median3(T[] a,int left,int right) {
         int center=(left+right)/2;
         if(a[center].compareTo(a[left])<0)
             swapReferences(a, left, center);
         if(a[right].compareTo(a[center])<0)
             swapReferences(a, center, right);
         if(a[right].compareTo(a[left])<0)
             swapReferences(a, left, right);
 
         swapReferences(a, center, right-1);
         return a[right-1];
     }
 }