快速排序

 思路1：

import java.util.Arrays;

public class QuickSortTest {

    public static void main(String[] args) {
        int arr[] = {-9, 78, 23, -567, 0, 70, -1, 900, 4561};

        System.out.println("排序前：" + Arrays.toString(arr));

        quickSort(arr, 0, arr.length - 1);

        System.out.println("排序后：" + Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int left, int right) {

        int pivot = 0;

        if (left < right) {

            pivot = partition(arr, left, right);

            quickSort(arr, left, pivot - 1);

            quickSort(arr, pivot + 1, right);

        }

    }


    private static int partition(int[] arr, int left, int right) {

        int key = arr[left];

        while (left < right) {

            while (left < right && arr[right] >= key) {

                right--;

            }

            arr[left] = arr[right];

            while (left < right && arr[left] <= key) {

                left++;

            }

            arr[right] = arr[left];

        }

        arr[right] = key;

        return left;

    }
}

 思路2：

public static void quicksort(int[] a, int left, int right) {
        int i, j, t, temp;
        if (left > right)
            return;
        temp = a[left]; //temp中存的就是基准数
        i = left;
        j = right;
        while (i != j) { //顺序很重要，要先从右边开始找
            while (a[j] >= temp && i < j)
                j--;
            while (a[i] <= temp && i < j)//再找右边的
                i++;
            if (i < j)//交换两个数在数组中的位置
            {
                t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
        }
        //最终将基准数归位
        a[left] = a[i];
        a[i] = temp;
        quicksort(a, left, i - 1);//继续处理左边的，这里是一个递归的过程
        quicksort(a, i + 1, right);//继续处理右边的 ，这里是一个递归的过程
    }

 思路3：

public static void qsort(int[] arr) {
        qsort(arr, 0, arr.length - 1);
    }

    public static void qsort(int[] arr, int low, int high) {
        if (low < high) {
            int pivot = partition(arr, low, high);//将表一分为二
            qsort(arr, low, pivot);//对低子表【递归】排序
            qsort(arr, pivot + 1, high);//递归对高子表递归排序
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivotkey = arr[low];//选择一个【基准元素】，通常选择第一个元素或者最后一个元素
        while (low < high) {//从表的两端【交替】地向中间扫描
            //将比基准元素小的交换到低端
            while (low < high && arr[high] >= pivotkey) {
                high--;
            }
            swap(arr, low, high);
            //将比基准元素大的交换到高端
            while (low < high && arr[low] <= pivotkey) {
                low++;
            }
            swap(arr, low, high);
        }
        return low;//此时基准元素在其排好序后的正确位置
    }

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