数据结构之快速排序

快速排序也属于内部排序，他是对冒泡排序的改进。基本思想是：在一趟排序时，选定一个值（一般选数组的中间值），在这趟排序过程中将数组中小于这个中间值数放在数组左边，大于中间值的数放在数组右边，然后在继续按照这种方法将左右两边的数进行快速排序，最终得到有序数组。示意图如下：

下面是用递归实现的快排：

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {-9,78,0,23,-567,70};
        QuickSort quickSort = new QuickSort();
        quickSort.sort(arr,0,arr.length-1);
        quickSort.print(arr);
    }

    /**
     * 对数组排序
     * @param arr 要排序的数组
     * @param left 左下标，从这个下标开始
     * @param right 右下标，到这个下标结束
     */
    private void sort(int[] arr,int left,int right){
        int l = left;
        int r = right;
        int temp = 0;
        int midValue = arr[(left+right)/2];//中间值
        while (l < r){
            //找左边大于midValue的元素
            while (arr[l] < midValue){
                l++;
            }
            //找右边小于midValue的元素
            while (arr[r] > midValue){
                r--;
            }
            //情况1：左边的值都小于中间值,右边值都大于中间值，退出循环
            if (l>=r){
                break;
            }
            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            //交换之后，左边到达中间值,右边还没比完，继续比右边下一个元素
            if (arr[l]==midValue){
                r--;
            }
            //交换之后，右边到达中间值,左边还没比完，继续比左边下一个元素
            if (arr[r] == midValue){
                l++;
            }
        }
        //出循环，先判断l，r的关系,否则会栈溢出
        if (l == r){
            l++;
            r--;
        }
        //左递归i
        if (left < r){
            sort(arr,left,r);
        }
        //右递归
        if (l < right){
            sort(arr,l,right);
        }
    }
    private void print(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
    }
}

值得注意的是while循环里的两个while循环执行后的情况。

1. 中间值的左边元素都小于中间值，右边元素都大于中间值，此时l>=r,退出while循环，执行左递归和右递归；
2. 找到了不满足条件的元素，交换；
3. 交换后，如果arr[l] == midValue,此时左边元素已经全部找完了，右边元素还没有全部找完，则r--，继续判断右边的元素；
4. 交换后，如果arr[r] == midValue,此时右边元素已经全部找完了，左边元素还没有全部找完，则l++，继续判断左边的元素；
5. 如果不是以上这四种情况，证明左右两个的元素都没有找完，继续循环即可。

出外层大循环后，还需判断l是否等于r，若l==r则需执行l++;r--；否则栈溢出！

还要记得，在左右递归之前要先判断一下传入的左右下标是否合法哦。