快速排序

思路

利用分治的思想，每次选择一个 pivot，将小于 pivot 的数放在左边，大于 pivot 的数放在右边。左右两边再分别选择一个 pivot。

代码

填坑法

public class QuickSort{
    public static void quickSort(int[] arr) {
        quickSort(arr, 0, arr.length-1);
    }

    private static void quickSort(int[] arr, int start, int end) {
        if(start < end){
        	int pivotIndex = partition(arr, start, end);
        	quickSort(arr, 0, pivotIndex - 1);
        	quickSort(arr, pivotIndex + 1, end);
        }                   
    }

    private static int partition(int[] arr, int start, int end) {
        int left = start;
        int right = end;

		//可以考虑，使用随机索引下的数作为 pivot，下面 random 的范围是[left,right+1)
        //int random = new Random().nextInt(right - left + 1) + left;
        //int tmp = arr[random];
        //arr[random] = arr[left];
        //arr[left] = tmp;
        
        int pivot = arr[left];
        while(left < right){
            while(left < right){
                if(arr[right] < pivot){
                    arr[left] = arr[right];
                    left ++;
                    break;
                }
                right --;
            }
            while(left < right){
                if(arr[left] > pivot){
                    arr[right] = arr[left];
                    right --;
                    break;
                }
                left ++;
            }
        }
        arr[left] = pivot;
        return left;
    }

    public static void main(String[] args){
        int[] array = new int[]{5,8,6,3,9,2,1,4,7};
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }
}

指针交换法

public class QuickSort{
    public static void quickSort(int[] arr) {
        quickSort(arr, 0, arr.length-1);
    }

    private static void quickSort(int[] arr, int start, int end) {
        if(start < end){
        	int pivotIndex = partition(arr, start, end);
        	quickSort(arr, 0, pivotIndex - 1);
        	quickSort(arr, pivotIndex + 1, end);
        }     
    }

    private static int partition(int[] arr, int start, int end) {
        int left = start;
        int right = end;
        
		//可以考虑，使用随机索引下的数作为 pivot，下面 random 的范围是[left,right+1)
        //int random = new Random().nextInt(right - left + 1) + left;
        //int tmp = arr[random];
        //arr[random] = arr[left];
        //arr[left] = tmp;
        
        int pivot = arr[left];
        while(left < right) {
            while (left < right && arr[right] > pivot) {
                right--;
            }
            while (left < right && arr[left] <= pivot) {
                left++;
            }
            if(left < right){
                int tmp = arr[left];
                arr[left] = arr[right];
                arr[right] = tmp;
            }

        }
        arr[start] = arr[left];
        arr[left] = pivot;
        return left;
    }

    public static void main(String[] args){
        int[] array = new int[]{8,7,6,5,3,2,8,1};
        quickSort(array);
        System.out.println(Arrays.toString(array));
    }
}

复杂度分析

时间复杂度

每一轮拆成 2 部分算，2部分加起来要 O(n) 的时间，平均有 logn 轮。平均时间复杂度 O(nlogn)。
最差每次的 pivot 都是最值，要 n 轮，O(n²)。
最好每次的 pivot 都是中间值，要 logn 轮， O(nlogn)。
可以考虑 pivotIndex 为随机数。

空间复杂度

无论是递归还是迭代都要用到额外的栈，平均和最好O(logn)
最差 O(n)

稳定性分析

涉及大范围交换，不稳定

优势

相对与冒泡排序，平均只需要 logn 轮比较和交换的次数。

适用场景

只要不需要稳定性，都可以使用快速排序。快速排序是平均运行时间最快的排序法。