高级排序算法-快速排序(Quick Sort)

1.含义

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

快速排序使用分治法来把一个串(list)分为两个子串(sub-lists)

2.算法描述

1. 从数列中挑出一个元素，称为“基准”(pivot)
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作;
3. 递归地把小于基准元素的子数列和大于基准值元素地子数列排序。

3.原理示意图

4.代码示例

package com.test.sort.advancedSort;

import java.util.Arrays;

/**
 * 快速排序
 * 1.找到基准值或者第一个数或者随机数(升级版)，本次使用升级版本的快速排序
 * 2.将基准值塞到数组的后边，从左边开始循环找到比基准值小的数据，进行基准值位置交换
 * 3.再从右边开始，循环找到比基准值小的数据，再进行基准值和比较数的交换
 * 4.循环上面的2，3步骤，左右左右进行比对和交换以后，
 * 5.直到基准值放入中间，左边都比基准值小，右边都比基准值大，再把左边进行递归下去，右边递归下去
 *
 * @Author df
 * @Date 2019/9/4 11:07
 * @Version 1.k0
 */
public class QuickSort {
    public static int[] quickSort(int[] arr, int start, int end) {
        // 最终这个si的值，是基准线的值
        int si = partition(arr, start, end);
        if (si > start) {
            quickSort(arr, start, si - 1);
        }
        if (si < end) {
            quickSort(arr, si + 1, end);
        }
        return arr;
    }

    // 分区操作函数
    public static int partition(int[] arr, int start, int end) {
        // 基准值关键词
        int pivot = (int) (start + Math.random() * (end - start + 1));
        // 将基准值移到数组的最后
        swap(arr, pivot, end);
        // 比基准数大的索引角标，用于换位置
        int smallindex = start - 1;
        for (int i = start; i <= end; i++) {
            if (arr[i] <= arr[end]) { //将第i个元素与基准值进行了一个对比
                smallindex++;
                if (i > smallindex) {
                    // 交换位置的util
                    swap(arr, i, smallindex);
                }
            }
        }
        return smallindex;
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    
    public static void main(String[] args) {
        int[] arr = {10, 34, 22, 20, 32, 35};
        System.out.println(Arrays.toString(quickSort(arr, 0, arr.length - 1)));
    }


}

java代码示例快速排序简单版本

   private static int[]  quickSort1(int[] oArr, int left, int right) {
        int i = left;
        int j = right;
        int mid = (i + j + 1) / 2;
        int pivot = oArr[mid];

        oArr[mid] = oArr[i];
        while (i < j) {
            while (oArr[j] >= pivot && i < j) {
                j--;
            }
            if (i < j) {
                oArr[i++] = oArr[j];
            }
            while (oArr[i] < pivot && i < j) {
                i++;
            }
            if (i < j) {
                oArr[j--] = oArr[i];
            }
        }
        oArr[i] = pivot;

        if (left < i - 1) {
            quickSort1(oArr, left, i - 1);
        }
        if (i + 1 < right) {
            quickSort1(oArr, i + 1, right);
        }
        return oArr;
    }

    public static void main(String[] args) {
        int[] testArr = {7, 3, 1, 5, 4, 6};
        System.out.println(Arrays.toString(quickSort1(testArr, 0, testArr.length - 1)));
    }

5.算法分析