快速排序（Java）

图解参考

一. 简介

• 思想：分治法
• 原理：在每一轮挑选出一个基准数，并让其他比他大的元素移动到一边，比他小的元素移动到数列的另一边，从而把数列拆分成两个部分。
• 平均时间复杂度：O(nlogn)

二. 基准数

1. 最简单的方式是选择数列的第一个元素。
   绝大多数情况下，此方法是没问题的，但对于一些情况是不合适的，如当第一个元素太大或太小（如逆序序列排序成顺序序列）等情况，会将算法“退化”。

2. 随机选择一个元素作为基准数。
   此方法，是对第一种方法的改进。

三. 元素的交换

1. 双边循环法
   （1）选定基准数；
   （2）设定两个指针left和right分别指向数列的最左和最右两个元素；
   （3）从right指针开始，让指针所指向的元素和基准数做比较，如果大于等于基准数，则指针向左移动；如果小于基准数，则right指针停止移动；
   （4）切换到left指针，让指针所指向的元素和基准数做比较，如果小于等于基准数，则指针向右移动；如果大于基准数，则right指针停止移动；
   （5）让left和right指针所指向的元素进行交换；

2. 单边循环法
   （1）选定基准数；
   （2）数值一个mark指针指向数列的起始位置，此mark指针代表小于基准数的边界；
   （3）从基准数的下一个位置开始遍历；
   （4）如果遍历到的数大于基准数，则继续遍历；如果遍历到数小于基准数，则将mark指针右移一位，让最新遍历到的数和mark指针所指向的数进行交换。

四. Java实现

1. 双边循环法

   import java.util.Arrays;
   
   public class MySort {
       public static void quickSort(int[] array,int startIndex, int endIndex) {
           //递归结束条件
           if (startIndex >= endIndex) {
               return;
           }
   
           //获取基准数位置
           int pivotIndex = partition(array, startIndex, endIndex);
           //根据基准数，分成两部分进行排序
           quickSort(array, startIndex, pivotIndex - 1);
           quickSort(array,pivotIndex + 1, endIndex);
       }
   
       //双边循环法(分治）
       private static int partition(int[] array, int startIndex, int endIndex) {
           //取 第一个位置（也可随机选取）作为基准数
           int pivot = array[startIndex];
           int left = startIndex;
           int right = endIndex;
   
           while (left != right) {
               //right指针比较并左移
               while (left < right && array[right] > pivot) {
                   right--;
               }
               //left指针比较并右移
               while (left < right && array[left] <= pivot) {
                   left++;
               }
               //交换left和right指针指向的元素
               if(left < right) {
                   int temp = array[left];
                   array[left] = array[right];
                   array[right] = temp;
               }
           }
   
           //pivot和指针重合点交换
           array[startIndex] = array[left];
           array[left] = pivot;
   
           return left;
       }
   
       public static void main(String[] args) {
           int[] array = new int[] {5,8,6,3,9,2,1,7};
           quickSort(array,0, array.length - 1);
           System.out.println(Arrays.toString(array));
       }
   
   }
   

   运行结果：

   [1, 2, 3, 5, 6, 7, 8, 9]
   

2. 单边循环法

   import java.util.Arrays;
   
   public class MySort {
       public static void quickSort(int[] array,int startIndex, int endIndex) {
           //递归结束条件
           if (startIndex >= endIndex) {
               return;
           }
   
           //获取基准数位置
           int pivotIndex = partition(array, startIndex, endIndex);
           //根据基准数，分成两部分进行排序
           quickSort(array, startIndex, pivotIndex - 1);
           quickSort(array,pivotIndex + 1, endIndex);
       }
   
       //单边循环法(分治）
       private static int partition(int[] array, int startIndex, int endIndex) {
           //取 第一个位置（也可随机选取）作为基准数
           int pivot = array[startIndex];
           int mark = startIndex;
   
           for (int i = startIndex; i <= endIndex; i++) {
               if (array[i] < pivot) {
                   mark++;
                   int temp = array[mark];
                   array[mark] = array[i];
                   array[i] = temp;
               }
           }
   
           array[startIndex] = array[mark];
           array[mark] = pivot;
   
           return mark;
       }
   
       public static void main(String[] args) {
           int[] array = new int[] {5,8,6,3,9,2,1,7};
           quickSort(array,0, array.length - 1);
           System.out.println(Arrays.toString(array));
       }
   
   }
   

   运行结果：

   [1, 2, 3, 5, 6, 7, 8, 9]