算法——快速排序

【1】方式一

①创建一个临时变量temp保存当前pivot的值
②r左移遇到小于temp的直接赋值给l，然后l右移，遇到大于temp的直接赋值给r
③知道r==l，将temp的值写到这个位置上

代码实现：

public static void quick1(int[] arr, int left, int right) {
        if (left >= right)
            return;
        //保存中轴值
        int temp = arr[left];
        int l = left;
        int r = right;
        while (l < r) {
            //r左移
            while (arr[r] > temp && r > l) {
                r--;
            }
            if (r > l) {
                arr[l++] = arr[r];
            }
            //l右移
            while (arr[l] < temp && l < r) {
                l++;
            }
            if (l < r) {
                arr[r--] = arr[l];
            }
        }
        //中轴放到合适的位置
        arr[r] = temp;

        //递归
        quick1(arr, left, r - 1);
        quick1(arr, r + 1, right);
    }

【2】方式二：

① 直接r右移，遇到小于pivot的就停在这里，然后l右移遇到大于pivot的就与刚才r的位置的值交换。
② 重复刚才的操作
③ 知道r==l，将pivot的值写到r与l重合的位置就行了

代码实现：

public static void quick2(int[] arr, int left, int right) {
        //等号不是必须的，有等号会提高效率
        if (left >= right)
            return;
        int l = left;
        int r = right;
        int temp = 0;
        int pivot = arr[left];
        while (r != l) {
            //右边找到小于等于pivot的
            while (arr[r] >= pivot && r > l) {
                r--;
            }
            //左边找到大于等于pivot的
            while (arr[l] <= pivot && l < r) {
                l++;
            }
            //交换这两个值，不写这句话效率降低，r=l的时候还会进行交换，这时直接跳出外层循环就好了
            if (r > l) {
                temp = arr[r];
                arr[r] = arr[l];
                arr[l] = temp;
            }
        }
        //将pivot的重合的值交换
        arr[left] = arr[l];
        arr[l] = pivot;
        //递归，先排左边，再排右边
        quick2(arr, left, r - 1);
        quick2(arr, r + 1, right);
    }

【3】测试

测试数组：int[] arr = {19, 97, 9, 17, 1, 8, 27};