快速排序（原始、随机）

思路

在数组中设置一个基准元素和两个哨兵，利用哨兵机制将比基准元素小的元素移动到基准元素左侧，比基准元素大的元素移动到基准元素右侧，然后把基准元素放到正确的位置，然后用递归对基准元素两侧的序列进行排序。

代码

(1) 将序列的第一个元素作为基准元素（常用）

此时序列最右边的哨兵要先动，原因见此篇分析：快速排序解惑——哨兵出发的顺序，简单地说就是确保与基准元素交换位置的那个元素，小于或者等于基准元素。

public static void quickSort(int[] arr, int leftBorder, int rightBorder) {
     if(leftBorder < rightBorder) {
         int left = leftBorder;
         int right = rightBorder;
         int key = arr[leftBorder];
         while(left < right) {
             while(left < right && arr[right] >= key) {
                 right--;
             }
             while(left < right && arr[left] <= key) {
                 left++;
             }
             if(left < right) {
                 swap(arr, left, right);
             }
         }
         if(leftBorder != left) {
             arr[leftBorder] = arr[left];
             arr[left] = key;
         }
         quickSort(arr, leftBorder, left-1);
         quickSort(arr, left+1, rightBorder);
     }
 }

(2) 随机选择基准元素

在序列中随机选择一个元素作为基准元素，再将该元素与序列的第一个元素交换，此时序列中的第一个元素为基准元素，这样就把问题转化到了情况(1)。

public static void quickSortRandom(int[] arr, int leftBorder, int rightBorder) {
    if(leftBorder < rightBorder) {
        int left = leftBorder;
        int right = rightBorder;
        int keyIndex = getRandomIndex(leftBorder, rightBorder);
        int key = arr[keyIndex];
        if(left != keyIndex) {
            swap(arr, left, keyIndex);
        }
        while(left < right) {
            while(left < right && arr[right] >= key) {
                right--;
            }
            while(left < right && arr[left] <= key) {
                left++;
            }
            if(left < right) {
                swap(arr, left, right);
            }
        }
        if(left != leftBorder) {
            arr[leftBorder] = arr[left];
            arr[left] = key;
        }
        quickSort(arr, leftBorder, left-1);
        quickSort(arr, left+1, rightBorder);
    }
}
public static int getRandomIndex(int start, int end) {
    return (int)(Math.random() * (end-start+1) + start);
}

性能分析

时间复杂度：

• 最好：选择的哨兵每次都能将待排序的序列平分，$T(n)=2T(n/2)+O(n)\Rightarrow T(n)=O(nlogn)$
• 最差：每次选择的哨兵都是序列中最小或者最大的元素，这样只能将一个长度为$n$的待排序序列分为长度为$n-1$的待排序序列和只包含一个元素的序列，$T(n)=T(n-1)+O(n)\Rightarrow T(n)=O(n^2)$
• 平均：$O(nlogn)$

空间复杂度：$O(1)$
稳定性： 不稳定，例如5, 1, 1，后面的一个1会被移动到数组的第一个位置。