Java的快速排序以及原理分析

给出一个数组

int[] arr={2,4,6,1,0,5,7,3};

以第一轮排序作为分析

对于{2,4,6,1,0,5,7,3}，以arr[0]也就是第一个数2作为分界值，左右两边指针分别从第二位和最后一位开始扫描

1. 先看右边，依次扫描3,7,5,0，到0的时候发现0<2， 此时退出扫描，right指针指向0
2. 再看左边，依次扫描，到4,发现4>2，此时退出扫描，left指针指向4
3. 此时判断，两边指针并没有出现right<=left，因此可以把arr[left]和arr[right]进行交换，此时数组变成了{2,0,6,1,4,5,7,3}
4. 右边继续扫描，右边扫到1,发现小于2，退出扫描，指向1
5. 左边继续扫描，右边扫到6,发现大于2，退出扫描，指向6
6. 此时判断，两边指针并没有出现right<=left，因此可以把arr[left]和arr[right]进行交换，此时数组变成了{2,0,1,6,4,5,7,3}
7. 接下来继续扫，发现right<=left了，这个时候right指向1，left指向6,直接终止扫描，第一轮排序结束
8. 为下一轮扫瞄进行分组，级交换arr[right]和arr[0]，因为按之前的分析，arr[right]<=arr[0]，并且返回right指针的位置记为partition，数组变成{1,0,2,6,4,5,7,3}，这样完成了第一轮的分界数2的左边比2都小，2的右边比2都大
9. 后续进行递归，以第一轮的partition位置进行分组，左边进行排序，右边进行排序，对于左边来说，对{1,0,2 }数组进行排序,对于右边来说，对{6,4,5,7,3}数组进行排序，到后面两边子数组排序到最后都只剩一个数的时候，不满足可行性判断lo(下标)>= hi(上标)，即排序完成

交换用工具类

public class SortUtils {
    public static void exch(int[] arr,int i,int j){
        int temp=0;
        temp=arr[j];
        arr[j]=arr[i];
        arr[i]=temp;
    }
}

快速排序的实现

public class QuickSort {
    public static void main(String[] args) {
        int[] arr={2,4,6,1,0,5,7,3};
        quickSort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));

    }

    public static void quickSort(int[] arr, int lo, int hi) {
        //可行性判断
        if (lo >= hi) {
            return;
        }
        int partition=partition(arr,lo,hi);
        quickSort(arr,lo,partition-1);
        quickSort(arr,partition+1,hi);

    }

    //分组，获取分组位置的索引
    public static int partition(int[] arr, int lo, int hi) {
        //用第一个数当初始分界值
        int key = arr[lo];
        int left = lo;
        int right = hi + 1;
        while (true) {
            //如果右边的数比左边大，则继续向左寻找
            while (arr[--right] > key) {
                //如果找到左边到底了，退出循环
                if (right == lo) {
                    break;
                }
            }
            //如果左边的数比左边小，则继续向右寻找
            while (arr[++left] < key) {
                //如果找到右边到底了，退出循环
                if (left == hi) {
                    break;
                }
            }
            //两边相遇，则不成立,退出循环
            if (left >= right) {
                break;
            } else {//否则对两边的元素进行交换
                SortUtils.exch(arr, left, right);
            }
        }
        //把分界值和相遇的地方进行交换，返回right作为分组位置
        SortUtils.exch(arr, lo, right);

        return right;
    }
}