排序算法5-快速排序

描述

快速排序是对冒泡排序基础上的优化版本，它打破了冒泡排序只能比对交换相邻元素的方式，并加入了“分治”思想

流程

1、对一序列，选定最左边的元素作为基数p；再定义i，使i依次从左到右寻找比基数p大的元素；再定义j，使j依次从右到左寻找比基数p小的元素；当i、j每每找到，便交换i、j元素，直到i、j相遇
2、将i、j相遇位置的元素与基数p所在元素进行交换，便得到元素p的左边都比p小，右边都比p大
3、对元素p的左边序列和右边序列重复走流程1、流程2，直到算法结束

代码实现

/**
 * 快速排序
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {0,1,5,3,9,2,6};
        sort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));

    }

    public static void sort(int[] arr, int l, int r) {
        if (l < r) {
            // 一趟快排，并返回交换后基数的下标
            int index = patition(arr, l, r);
            // 递归排序基数左边的数组
            sort(arr, l, index - 1);
            // 递归排序基数右边的数组
            sort(arr, index + 1, r);
        }
    }

    public static int patition(int[] arr, int l, int r) {
        //每次排序选择最左边的元素为基数
        int p = arr[l];
        int i = l;
        int j = r;
        //直到i、j相遇
        while (i < j) {
            // 依次从右往左找小于基数的数
            while (arr[j] >= p && j > i) {
                j--;
            }

            // 依次从左往右找大于基数的数
            while (arr[i] <= p && j > i) {
                i++;
            }
            // 找到后交换两个数
            swap(arr, i, j);
        }
        // 使划分好的数分布在基数两侧
        swap(arr, l, i);
        return i;
    }

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

性能

在最优的情况下，快速排序算法的时间复杂度为O(nlogn)
在最坏的情况下，快速排序算法的时间复杂度为O(n^2)
平均时间复杂度为O(nlogn)

在最优的情况下，快速排序算法的空间复杂度为O(logn)
在最坏的情况下，快速排序算法的空间复杂度为O(n)
平均空间复杂度为O(logn)

元素的比较和交换是跳跃进行的，因此，快速排序是一种不稳定的排序方法