快速排序算法（JAVA实现）

快速排序是所有内部排序算法中平均性能最优的排序算法。

介绍

快速排序（Quicksort）是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

核心思想

快速排序的单趟排序思想是：

在一个无序数组中取一个数key，每一趟排序的最终目的是：让key的左边的所有数小于key，key的右边都大于key（假设排升序）。

先不考虑这一步怎么实现，我们接着往下看。

以下面的数组为例，可以观察到的是，在完成单趟排序后，无论key的左边和右边是否有序，key都来到了它在整个数组有序时应该来到的位置，也就是这个数组的第四个位置。所以对于key来说，它已经被排好序了。
 

快速排序法示意图

快速排序法应用实例：

 要求: 对 [-9,78,0,23,-567,70] 进行从小到大的排序，要求使用快速排序法。

说明[验证分析]:

如果取消左右递归，结果是  -9 -567 0 23 78 70

如果取消右递归,结果是  -567 -9 0 23 78 70

如果取消左递归,结果是  -9 -567 0 23 70 78

基础测试：

public static void quickSort(int left, int right, int[] arr) {
        int l = left;
        int r = right;
        int pivot = arr[(left + right) / 2];
        int temp = 0;
        while (l < r) {
            while (arr[l] < pivot) {
                l += 1;
            }
            while (arr[r] > pivot) {
                r -= 1;
            }
            if (l >= r) {
                break;
            }

            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            if (arr[l] == pivot) {
                r -= 1;
            }

            if (arr[r] == pivot) {
                l += 1;
            }
    }
    if (l == r) {
        l += 1;
        r -= 1;
    }

    if (left < r) {
        quickSort(left, r, arr);
    }

    if (right > l) {
        quickSort(l, right, arr);
    }
}

案例实现代码：

import java.util.Scanner;

public class Test{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] arr = new int[n];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = scanner.nextInt();
        }

        QuickSort(arr, 0, arr.length - 1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
    public static void QuickSort(int[] arr,int low,int high){
        if(low < high){
            int pivotpos = Partition(arr,low,high);
            QuickSort(arr,low,pivotpos-1);
            QuickSort(arr,pivotpos+1,high);
        }
    }

    public static int Partition(int[] arr,int low,int high){
        int pivot = arr[low];
        while (low < high){
            while (low < high && arr[high] >= pivot){
                --high;
            }
            arr[low] = arr[high];
            while (low < high && arr[low] <= pivot){
                ++low;
            }
            arr[high] = arr[low];
        }
        arr[low] = pivot;
        return low;
    }
}