Java快速排序

import java.util.Scanner;
import org.junit.Test;
public class Main5 {
    /**
     * 快排两头逼近一趟划分过程
     * @param a 子序列
     * @param low 子序列左边界下标
     * @param high 子序列右边界下标
     * @return 基准元素下标
     */
    public static int partition(int[] a, int low, int high) {
        int key = a[low];// 将子序列第一个元素抽出来作为基准元素
        int tmpLow=low;
        int tmpHigh=high;
        while (low < high) {
            while (low < high && a[high] >= key) {
                high--;
            } // 当a[right]<key时退出循环
            a[low] = a[high];// 将a[right]移动到前面


            while (low < high && a[low] <= key) {
                low++;
            } // 当a[left]>key时退出循环
            a[high] = a[low];// 将a[left]移动到后面
        } // 当left==right时，说明一趟两头逼近已经结束，将基准元素插入中间位置
        a[low] = key;
        return low;

    }

    /**
     * 快速排序（采用两头逼近的办法）
     * @param a 待排序序列
     * @param left
     * @param right
     */
    public static void quickSort(int[] a, int left, int right) {
        if (right - left == 0) {// 当待排序列中只有一个元素时，显然已经有序，结束递归
            return;
        }
        int middleIndex = partition(a, left, right);
        if(middleIndex!=left){//这个判断条件必须要加，因为如果本来就是已经排好序的，那么第一趟两头向中间逼近结束后返回的基准元素下标是0，这个时候再计算middleIndex - 1就会出现负的下标
            quickSort(a, left, middleIndex - 1);
        }
        quickSort(a, middleIndex + 1, right);
    }

    @Test
    public void testQuickSort() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数组长度！");
        int n = sc.nextInt();
        int[] a = new int[n];
        System.out.println("请输入数组元素");
        for (int i = 0; i < a.length; i++) {
            a[i] = sc.nextInt();
        }

        int left = 0;
        int right = n - 1;

        quickSort(a, left, right);

        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
//  1 3 5 3 1 5 2 8 6 8
}

写在后面的话：快速排序也叫分区排序，是目前应用最广泛的排序算法，快速排序是一个效率很高的排序算法，但是对于长度很小的序列快速排序算法的速度并不比一些简单的排序算法快（有研究证明过的），可以对快速排序算法进行改进，设定一个长度L,当子序列长度在0-L的范围内，可以对子序列进行直接插入排序，这样就可以提高快速排序的效率了，还可以有效解决一个问题：StackOverflowError，递归是一种非常好的思想，递归写的算法简洁高效，但是递归层次过深会导致栈溢出，所以一般不建议使用递归。改进的快排算法请看下回分解。