快速排序详解

快速排序详解（符java代码）

1.算法思想

1. 从待排序区间选择一个数，作为基准值(pivot)；

2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可 以包含相等的）放到基准值的右边；

3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间 的长度 == 0，代表没有数据。

private static void quickSort(int[] arr, int left, int right) {
    if (left > right) {//表示已经有序
        return;
    }
    int partition = partition(arr, left, right);
    //得到的partition左边全是小于等于它的数，右边全是大于它的数
    quickSort(arr, left, partition-1);//对partition左边进行快排
    quickSort(arr, partition+1, right);//对partition右边进行快排
    }

2.实现partition思路

2.1 honor法

1. 先从右往左找到一个比基数小的数， 再从左往右找到一个比基数大的数
2. 交换两个数 ，然后继续执行1,2操作。
3. 最后交换right指针和基数指针所指的数
4. 注意！ 如果取第一个数为基数时，一定要先从右找

private static int partition1(int[] arr, int left, int right) {
    int base = left; //用于比较的基数下标
    while (left < right) {//先从右向左找比基数小的数
        while (left < right && arr[right] >= arr[base]) {
            right--;
        }
        while (left < right && arr[left] <= arr[base]) {//再从左向右找比基数大的数
            left++;
        }
        if (left < right) {
            swap(arr, left, right);//然后交换
        }
    }
    swap(arr, base, right);//最后交换基数和right
    return right;
}
//用于交换的函数
private static void swap(int[] arr, int left, int right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
}

2.2 挖坑法

基本思路和honor 法一致，只是不再进行交换，而是进行赋值（挖坑和填坑的过程）

private static int partition2(int[] arr, int left, int right) {
    int base = arr[left]; //1.先把用于比较的基数挖出来
    while (left < right) {
        //2.从右向左找小于base的数填入坑
        while (left < right && arr[right] >= base) {
            right--;
        }
        arr[left] = arr[right];
        //2.从左向右找大于base的数填入坑
        while (left < right && arr[left] <= base) {
            left++;
        }
        arr[right] = arr[left];
    }
    //4.最后将base填入坑
    arr[right] = base;

    return right;
}

因为没有用到swap函数，只是在本身的数组位置上挖坑填坑，所以更加高效，算是honor法的优化版本

2.3 前后下标法

思路：用前后两个下标指针包括的范围来表示比基数大于等于的数，该范围以外的数就是比基数要小的数

    private static int partition3(int[] arr, int left, int right) {
        int separateIndex = left + 1;//范围的尾部指针
        for (int i = left + 1; i <= right; i++) {
            // 1.当遇到比基数小的数才做处理  处理方法为
            // 把separateIndex和当前数交换，然后separateIndex++
            if (arr[i] < arr[left]) {
                swap(arr, separateIndex, i);
                separateIndex++;
            }
        }
        //最后再把基数和separateIndex - 1下标元素交换
        swap(arr, separateIndex - 1, left);
        return separateIndex - 1;
    }

3.算法分析

3.1 性能分析

时间复杂度 空间复杂度 稳定性：

最好 平均 最坏 最好 平均 最坏

O(n * log(n)) O(n * log(n)) O(n^2) O(log(n)) O(log(n)) O(n) 不稳定

3.2 优化分析

1. 小细节优化， 比如i从left+1开始，尽可能的使用最少的变量等
2. 基点的选择，最坏情况 如所有元素一样时，选择最左边元素为基点，就会造成算法将执行partition n次，时间复杂度是O(n^2), 为了避免这种情况，我们可以对基点的选择进行优化 ①可以随机选择 ②可以三点取中
3. partition过程中 相等的特殊处理 ，使得相等的元素不需要再进行下一轮快排
4. 待排序区间小于一个阈值时（例如 48），使用直接插入排序 (因为插入排序在数据量小的时候很快)

3.3 优化版本partition

1. 定义一个less和more表示小于base的区间和大于base的区间
2. 遍历过程中，遇到大于base的数，swap(arr, --more, left);
3. 遇到小于base的数，swap(arr, ++less, left++);
4. 遇到等于base的数，left++;
5. 最后返回大于和小于区间边界return new int[]{less, more};

    private static int[] partition4(int[] arr, int left, int right) {
        int base = arr[right]; //用于比较的基数
        int more = right + 1, less = left - 1;//大于base和小于base的区间边界
        while (left < more) {
            if (arr[left] > base) { //注意!  当前数比base大时  交换回来的数要重新判断
                swap(arr, --more, left);
            } else if (arr[left] < base) {
                swap(arr, ++less, left++);
            } else {
                left++;
            }
        }
        return new int[]{less, more};
    }

4.最终版本代码实现（java）

public static void main(String[] args) {
        int[] arr = new int[20];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) (Math.random() * 100);
        }
        System.out.println("排序前" + Arrays.toString(arr));
        quickSort("排序后" + arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
}

private static void quickSort(int[] arr, int left, int right) {
        if (left > right) {
            return;
        }
        int[] partition = partition(arr, left, right);
        quickSort(arr, left, partition[0]);
        quickSort(arr, partition[1], right);
}

private static int[] partition(int[] arr, int left, int right) {
        int base = arr[right]; //用于比较的基数
        int more = right + 1, less = left - 1;//大于base和小于base的区间边界
        while (left < more) {
            if (arr[left] > base) { //注意!  当前数比base大时  交换回来的数要重新判断
                swap(arr, --more, left);
            } else if (arr[left] < base) {
                swap(arr, ++less, left++);
            } else {
                left++;
            }
        }
        return new int[]{less, more};
}

private static void swap(int[] arr, int i, int j) {
	int tmp = arr[i];
	arr[i] = arr[j];
	arr[j] = tmp;
}

运行结果

排序前[15, 15, 20, 92, 55, 24, 57, 76, 8, 54, 81, 91, 94, 64, 31, 61, 10, 49, 75, 38]
排序后[8, 10, 15, 15, 20, 24, 31, 38, 49, 54, 55, 57, 61, 64, 75, 76, 81, 91, 92, 94]