Java中的快速排序算法

快速排序是一种比较常用的排序算法，它的原理是先在待排序的区间中，找一个基准值，再遍历整个待排序区间，将比基准值小（可以等于）的值放到基准值的左边，将比基准值大（也可以包含相等）的值放在基准值的右边，再对分出的两组（两边的数据）按照同样的方法进行操作，最终将会得到有序的数。

我们可以利用递归、非递归的方法，写出快速排序的算法代码。

递归实现

用递归方法实现就是在其中主要的就是分组的过程，再完成递归即可实现排序。

下面介绍几种分组方法。

//交换
public void swap(int[] arr,int i,int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}
public int partition1(int[] arr, int left, int right){
    //基准值
    int key = arr[left];
    int start = left;
    while(left < right){
        //一定要先从后向前找第一个小于key的数据位置， 否则数据的位置会产生错误
        while(left < right && arr[right] >= key) {
            right--;
        }
        //从前向后找第一个大于key的数据位置
        while(left < right &&arr[left] <= key) {
            left++;
        }
        //交换
        swap(arr, left, right);
    }
    //把基准值和相遇的位置的数据进行交换
    //错误： arr[left] = key; 相遇位置的数据被覆盖
    swap(arr, left, start);
    return left;
}

public int partition2(int[] arr, int left, int right){
    //获取基准值
    int key = arr[left];
    //挖坑填坑
    while(left < right) {
        //从右边找第一个小于key的数据，填左边的坑
        while(left < right && arr[right] >= key) {
            right--;
        }
        //填坑
        arr[left] = arr[right];
        //从左边找第一个大于key的数据，填右边的坑
        while(left < right && arr[left] <= key) {
            left++;
        }
        //填坑
        arr[right] = arr[left];
    }
    //填基准值到中间相遇的位置
    arr[left] = key;
    return left;
}

//三数取中法： 为了让数据分组更加均衡
public int getMid(int[] arr, int left, int right){
    // 从 arr[left], arr[mid], arr[right],中选一个中间值
    int mid = (left + right) / 2;
    if(arr[mid] > arr[left]){
        if(arr[mid] < arr[right]) {
            return mid;
        } else {
            if(arr[left] > arr[right]) {
                return left;
            } else {
                return right;
            }
        }
    } else {
        if(arr[mid] > arr[right]) {
            return mid;
        } else {
            // mid <= left, <= right
            if(arr[left] < arr[right]) {
                return left;
            } else {
                return right;
            }
        }
    }
}
public int partition3(int[] arr, int left, int right){
    //三数取中
    int mid = getMid(arr, left, right);
    swap(arr, left, mid);
    int key = arr[left];
    int prev = left;    //最后一个小于key的位置
    int cur = left + 1; //下一个小于key的位置
    while(cur <= right){
        //如果cur找到下一个小于key的位置，并且prev 和 cur之间有大于key的值，则交换prev, cur的值
        if(arr[cur] < key && ++prev != cur) {
            swap(arr, prev, cur);
        }
        cur++;
    }
    swap(arr, left, prev);
    return prev;
}

以上是三种分组的方法，都是符合快速排序的原理的，下面来看看，用递归的方法，是如何实现快速排序的算法的，代码如下：

/*
快速排序
时间复杂度：O(nlogn)
空间复杂度：O(logn)
稳定性：不稳定
 */
public void quickSort(int[] arr,int left,int right) {
    if(left < right){
        //int mid = partition1(arr, left, right);
        //int mid = partition2(arr, left, right);
        int mid = partition3(arr, left, right);
        quickSort(arr, left, mid-1);
        quickSort(arr, mid+1, right);
    }
}

递归的实现，我认为是比较好理解的。

非递归实现

利用非递归的方法实现，也是要按照递归的思路进行的。可能相对来说，有点不是太好理解。
代码如下：

//非递归快排
public void quickSortNo(int[] arr) {
    int left = 0;
    int right = arr.length-1;
    //用栈来记录
    Stack<Integer> stack = new Stack<>();
    if (left < right) {
        stack.push(left);
        stack.push(right);
    }
    while (!stack.isEmpty()) {
        //取出栈顶的一对区间值
        int right1 = stack.pop();
        int left1 = stack.pop();
        //分组
        int mid = partition3(arr,left1,right1);
        //新的分组继续压栈
        if (mid-1 > left1) {
            stack.push(left1);
            stack.push(mid-1);
        }
        if (mid+1 < right1) {
            stack.push(mid+1);
            stack.push(right1);
        }
    }
}

以上就是快速排序的递归、非递归的代码实现过程，个人认为递归的更容易理解。