快速排序算法

快排是一种比较常见得算法，常用于对于数据进行排序，其排序速度较快，时间复杂度为nlogn，且是一种不稳定的排序。

快排的核心思想为分治和递归，基本实现思想为：

1.确定一个比较数和排序的区间左边界和右边界。

2.确定比较策略，使该数左边的区间小于等于该数，该数右边的区间都大于等于该数

3.进行递归调用排序区间的左边部分和右边部分

实现过程中第二部分比较复杂，实验过程也比较多

目前主流的写法有两种：

1.以首元素为基准：

 public static void qSort2(int[] arr, int l, int r) {
//        当区间只有一个数或者没有时，不必排序
        if(l >= r){
            return;
        }
        int i = l,j = r,pivot = arr[l];
        while(i < j){
            //从右边开始找到第一个小于的数
            while(i < j && arr[j] >= pivot){
                j--;
            }
            //当还未遍历完
            if(i < j){
                arr[i++] = arr[j];
            }
            //找到第一个大于的数
            while(i < j && arr[i] <= pivot){
                i++;
            }
            if(i < j){
                arr[j--] = arr[i];
            }
        }
        //数放在中间
        arr[i] = pivot;
        qSort2(arr,l,j - 1);
        qSort2(arr,j + 1,r);
}

2.随机设置基准（不过需注意当以i进行分界时，不可将基准设为(i + j ）>> 2,否则死循环，也不可将其设为l,否则会越界；同理，当以j进行分界时，不可将基准设(i + j + 1) >> 2,否则死循环，也不可以设为r，否则越界）

代码如下：

public static void qSort1(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int pivot = arr[r];
        int i = l - 1, j = r + 1;
        while (i < j) {
            //保证左边的数都小于该数
            do {
                i++;
            } while (arr[i] < pivot);
            //保证右边的数都大于该数
            do {
                j--;
            } while (arr[j] > pivot);
            //进行交换
            if (i < j) {
                int t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;

            }
            //分别排序左边和右边
        }
        qSort1(arr, l, i - 1);
        qSort1(arr, i, r);
    }

完整代码如下：

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        //进行读入
        int n;
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        n = Integer.parseInt(bufferedReader.readLine());
        //读入数据
        String[] arr = bufferedReader.readLine().split(" ");
        int[] arrs = new int[n + 1];
        for (int i = 0; i < n; i++) {
            arrs[i] = Integer.parseInt(arr[i]);
        }
        //防止读入出错
        int l = 0;
        int r = n - 1;
        qSort1(arrs, l, r);
        for (int i = 0; i <= r; i++) {
            System.out.printf(arrs[i] + " ");
        }
        bufferedReader.close();
    }

    //第一种写法
    public static void qSort1(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int pivot = arr[r];
        int i = l - 1, j = r + 1;
        while (i < j) {
            //保证左边的数都小于该数
            do {
                i++;
            } while (arr[i] < pivot);
            //保证右边的数都大于该数
            do {
                j--;
            } while (arr[j] > pivot);
            //进行交换
            if (i < j) {
                int t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;

            }
            //分别排序左边和右边
        }
        qSort1(arr, l, i - 1);
        qSort1(arr, i, r);
    }

    //第二种写法
    //例外标注下static和public位置可以互换，其他不可
    public static void qSort2(int[] arr, int l, int r) {
//        当区间只有一个数或者没有时，不必排序
        if(l >= r){
            return;
        }
        int i = l,j = r,pivot = arr[l];
        while(i < j){
            //从右边开始找到第一个小于的数
            while(i < j && arr[j] >= pivot){
                j--;
            }
            //当还未遍历完
            if(i < j){
                arr[i++] = arr[j];
            }
            //找到第一个大于的数
            while(i < j && arr[i] <= pivot){
                i++;
            }
            if(i < j){
                arr[j--] = arr[i];
            }
        }
        //数放在中间
        arr[i] = pivot;
        qSort2(arr,l,j - 1);
        qSort2(arr,j + 1,r);
    }
}