开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第6天，点击查看活动详情

前序

上一篇： 归并排序

快速排序

理论

首先快速排序是基于冒泡排序进行优化处理的一个算法思想，是由 C.A.R.Hoare（Charles Antony Richard Hoare，东尼·霍尔）在 1962 年提出。

算法的思想里面使用了冒泡排序的算法 将相邻的两个数据进行数据对比，如果右边的小于数据左边的数据那么进行相邻的数据进行数据对比，快速排序并且使用了分治法的思想进行数据 分组处理。 核心思想

对于一组数据进行排序处理的时候将原本的数据根据一定基准划分为 两个数组 其中左边的 都是小于基准数据的，然后右边的是大于基准数据的，然后呢 关于大于或者小于基准数是因为会进行选择一个数进行数据分治处理 ，一般而言都是使用第一个。

清晰的图解

下面的图片说明比较清晰

实践

coding

/***
 * quickSort 测试
 */
@Test
public void quickSortTest() {
    int[] ints = {1, 3, 5, 8, 2, 2, 7, 7, 6, 88, 23, 56, 21, 15};
    System.out.println("原始数组数据");
    for (int i = 0; i < ints.length; i++) {
        System.out.print(ints[i] + ",");
    }
    long l = System.nanoTime();
    //核心排序算法
    ints = quickSort(ints, 0, ints.length - 1);
    // 使用纳秒计算时间信息
    System.out.println("耗时" + (System.nanoTime() - l));
    System.out.println("排序之后的数据");
    for (int i = 0; i < ints.length; i++) {
        System.out.print(ints[i] + ",");
    }

}

/**
 * 核心排序算法
 *
 * @param arr
 * @param left
 * @param right
 * @return xx
 */
private int[] quickSort(int[] arr, int left, int right) {
    //当前需要进行的数据存在多个
    if (left < right) {
        //计算 基数位置 的基准数据应当在的位置
        int partitionIndex = partition(arr, left, right);
        // 对基本数据的左边进行排序
        quickSort(arr, left, partitionIndex - 1);
        //对基本数据的右边进行排序
        quickSort(arr, partitionIndex + 1, right);
    }
    return arr;
}

/**
 * 计算默认 数组中 的第一个数据应该在的基数位置
 * @param arr 数组
 * @param left 基本数据比较初始索引
 * @param right 当前数组 最末位数据索引
 * @return xx
 */
private int partition(int[] arr, int left, int right) {
    // 设定基准值（pivot）
    int pivot = left;
    int index = pivot + 1;
    for (int i = index; i <= right; i++) {
        //
        if (arr[i] < arr[pivot]) {
            swap(arr, i, index);
            index++;
        }
    }
    swap(arr, pivot, index - 1);
    return index - 1;
}

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

测试结果

总结

快速排序的话，它是居于冒泡排序 寻找基数的核心位置进行位置交换，然后使用分治法进行处理分块进行，递归调用处理。

Ending

下一篇：堆排序