package leo.class03_05;

import leo.util.ArrayUtil;

import java.util.Arrays;
import java.util.Stack;

/**
 * @author Leo
 * @ClassName QuickSort1
 * @DATE 2020/11/26 11:17 上午
 * @Description 快排1.0
 * O(N²) 最差情况
 * 范围内最后一个数为比较值x,[<=x>],x一定在左侧的最后一个位置,返回比较值得下标
 * 只记录右侧最小位置下标,如果index的值小于或等于右侧最后位置的数,
 * index与最小位置的数后一位交换,最小位置下标更新
 *
 * T(N) = a * T(N/b) + O(N^d)(其中的a、b、d都是常数)
 * 的递归函数，可以直接通过Master公式来确定时间复杂度
 * 如果 log(b,a) < d，复杂度为O(N^d)
 * 如果 log(b,a) > d，复杂度为O(N^log(b,a))
 * 如果 log(b,a) == d，复杂度为O(N^d  * logN)
 *
 */
class QuickSort1 {
    public static void quickSort(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    private static void process(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int m = partition(arr, l, r);
        process(arr, l, m-1);
        process(arr, m + 1, r);
    }

    private static int partition(int[] arr, int l, int r) {
        if (l > r) {
            return -1;
        }
        if (l == r) {
            return l;
        }
        int less = l-1;
        int index = l;
        while (index < r) {
            if (arr[index] <= arr[r]) {
                swap(arr, index, ++less);
            }
            index++;
        }
        swap(arr, r, ++less);
        return less;
    }

    private static void swap(int[] arr, int i, int j) {
        if (i == j || arr[i] == arr[j]) {
            return;
        }
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

}


/**
 * @author Leo
 * @ClassName QuickSort1
 * @DATE 2020/11/26 11:17 上午
 * @Description 快排2.0
 * O(N²) 最差情况
 * 中间位置固定,左右两边有序
 *
 */
class QuickSort2 {

    public static void quickSort(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    public static void process(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int[] equalsArea = partition(arr, l, r);
        process(arr, l, equalsArea[0] - 1);
        process(arr, equalsArea[1] + 1, r);
    }

    //netherlandsFlag
    //荷兰国旗问题
    private static int[] partition(int[] arr, int l, int r) {
        if (l > r) {
            return new int[]{-1, -1};
        }
        if (l == r) {
            return new int[]{l, r};
        }

        int leftIndex = l - 1;
        int rightIndex = r;
        int index = l;
        while (index < rightIndex) {
            if (arr[index] < arr[r]) {
                swap(arr, index++, ++leftIndex);
            } else if (arr[index] > arr[r]) {
                swap(arr, index, --rightIndex);
            }else{
                index++;
            }
        }
        swap(arr, r, rightIndex);
        return new int[]{leftIndex+1, rightIndex};
    }


    private static void swap(int[] arr, int i, int j) {
        if (i == j || arr[i] == arr[j]) {
            return;
        }
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }
}


/**
 * @author Leo
 * @ClassName QuickSort1
 * @DATE 2020/11/26 11:17 上午
 * @Description 快排3.0
 * O(N*logN)
 * 额外空间复杂度o(n)
 *
 */
class QuickSort3 {

    public static void quickSort(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    public static void process(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        swap(arr, (int) (l + (Math.random() * (r - l + 1))), r);
        int[] equalArea = partition(arr, l, r);
        process(arr, l, equalArea[0] - 1);
        process(arr, equalArea[1] + 1, r);
    }

    public static int[] partition(int[] arr, int l, int r) {
        if (l > r) {
            return new int[]{-1, -1};
        }
        if (l == r) {
            return new int[]{l, r};
        }
        int leftIndex = l - 1;
        int rightIndex = r;
        int index = l;
        while (index < rightIndex) {
            if (arr[index] == arr[r]) {
                index++;
            } else if (arr[index] < arr[r]) {
                swap(arr, index++, ++leftIndex);
            } else if (arr[index] > arr[r]) {
                swap(arr, index, --rightIndex);
            }
        }
        swap(arr, r, rightIndex);

        return new int[]{leftIndex + 1, rightIndex};
    }

    public static void swap(int[] arr, int i, int j) {
        if (arr[i] == arr[j] || i == j) {
            return;
        }
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }
}


class QuickSort3_1{

    public static void quickSort(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return;
        }

        process(arr, 0, arr.length - 1);
    }

    private static void process(int[] arr, int l, int r) {

        if (l >= r) {
            return;
        }

        swap(arr, (int) (l + ((r - l + 1) * Math.random())), r);
        int[] equalArea = partition(arr, l, r);
        process(arr, l, equalArea[0] - 1);
        process(arr, equalArea[1] + 1, r);

    }

    private static int[] partition(int[] arr, int l, int r) {
        if (l == r) {
            return new int[]{l, r};
        }
        int leftIndex = l - 1;
        int rightIndex = r;
        int index = l;
        while (index < rightIndex) {
            if (arr[index] == arr[r]) {
                index++;
            } else if (arr[index] > arr[r]) {
                swap(arr, index, --rightIndex);
            } else if (arr[index] < arr[r]) {
                swap(arr, index++, ++leftIndex);
            }
        }
        swap(arr, r, rightIndex);
        return new int[]{leftIndex + 1, rightIndex};

    }


    public static void swap(int[] arr, int i, int j) {
        if (arr[i] == arr[j] || i == j) {
            return;
        }
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];

    }


}


class QuickSort3_2{

    public static void quickSort(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    public static void process(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        swap(arr, (int) (l + ((r - l + 1) * Math.random())), r);
        int[] equalArea = partition(arr, l, r);
        process(arr, l, equalArea[0] - 1);
        process(arr, equalArea[1] + 1, r);
    }

    private static int[] partition(int[] arr, int l, int r) {
        if (l == r) {
            return new int[]{l, r};
        }
        int leftIndex = l - 1;
        int rightIndex = r;
        int index = l;
        while (index < rightIndex) {
            if (arr[index] == arr[r]) {
                index++;
            } else if (arr[index] > arr[r]) {
                swap(arr, index, --rightIndex);
            } else if (arr[index] < arr[r]) {
                swap(arr, index++, ++leftIndex);
            }
        }
        swap(arr, r, rightIndex);
        return new int[]{leftIndex + 1, rightIndex};


    }

    private static void swap(int[] arr, int i, int j) {
        if (i == j || arr[i] == arr[j]) {
            return;
        }
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

}

class QuickSort3_3{

    public static void quickSort(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    private static void process(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int[] equalArea = partition(arr, l, r);
        process(arr, l, equalArea[0] - 1);
        process(arr, equalArea[1] + 1, r);
    }

    public static int[] partition(int[] arr, int l, int r) {
        if (l > r) {
            return new int[]{-1, -1};
        }
        if (l == r) {
            return new int[]{l, r};
        }
        int leftIndex = l - 1;
        int rightIndex = r;
        int index = l;
        while (index < rightIndex) {
            if (arr[index] == arr[r]) {
                index++;
            } else if (arr[index] > arr[r]) {
                swap(arr, index, --rightIndex);
            } else if (arr[index] < arr[r]) {
                swap(arr, index++, ++leftIndex);
            }
        }
        swap(arr, r, rightIndex);
        return new int[]{leftIndex + 1, rightIndex};
    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j || arr[i] == arr[j]) {
            return;
        }
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }
}

class QuickSort3_4{

    public static void quickSort(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    public static void process(int[] arr, int l, int r) {
        if (l >= r) {
            return;
        }
        int[] equalArea = partition(arr, l, r);
        process(arr, l, equalArea[0] - 1);
        process(arr, equalArea[0] + 1, r);
    }

    private static int[] partition(int[] arr, int l, int r) {

        int leftIndex = l - 1;
        int rightIndex = r;
        int index = l;
        while (index < rightIndex) {
            if (arr[index] == arr[r]) {
                index++;
            } else if (arr[index] > arr[r]) {
                swap(arr, index, --rightIndex);
            } else if (arr[index] < arr[r]) {
                swap(arr, index++, ++leftIndex);
            }
        }
        swap(arr, r, rightIndex);
        return new int[]{leftIndex + 1, rightIndex};


    }

    public static void swap(int[] arr, int i, int j) {
        if (i == j || arr[i] == arr[j]) {
            return;
        }
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }

}

class QuickSortUnRecursive{

    private static class Op {
        public int l;
        public int r;

        public Op(int l, int r) {
            this.l = l;
            this.r = r;
        }
    }

    public static void quickSort(int[] arr) {
        if (arr.length < 2 || arr == null) {
            return;
        }
        swap(arr, arr.length - 1, (int) (arr.length * Math.random()));
        int[] equalArea = partition(arr, 0, arr.length - 1);
        Stack<Op> stack = new Stack<>();
        int l = equalArea[0] - 1;
        int r = equalArea[1] + 1;
        stack.push(new Op(0, l));
        stack.push(new Op(r, arr.length - 1));
        while (!stack.isEmpty()) {
            Op pop = stack.pop();
            int pl = pop.l;
            int pr = pop.r;
            if (pl < pr) {
                swap(arr, (int) (pl + (Math.random() * (pr - pl + 1))), pr);
                equalArea = partition(arr, pl, pr);
                l = equalArea[0] - 1;
                r = equalArea[1] + 1;
                stack.push(new Op(pl, l));
                stack.push(new Op(r, pr));
            }
        }

    }



    public static int[] partition(int[] arr, int l, int r) {
        if (l > r) {
            return new int[]{-1, -1};
        }
        if (l==r){
            return new int[]{l, r};
        }
        int leftIndex = l - 1;
        int rightIndex = r;
        int index = l;
        while (index < rightIndex) {
            if (arr[index] == arr[r]) {
                index++;
            } else if (arr[index] < arr[r]) {
                swap(arr, index++, ++leftIndex);
            } else if (arr[index] > arr[r]) {
                swap(arr, index, --rightIndex);
            }
        }
        swap(arr, r, rightIndex);
        return new int[]{leftIndex + 1, rightIndex};
    }

    private static void swap(int[] arr, int i, int j) {
        if (i == j || arr[i] == arr[j]) {
            return;
        }
        arr[i] = arr[i] ^ arr[j];
        arr[j] = arr[i] ^ arr[j];
        arr[i] = arr[i] ^ arr[j];
    }


}


class TestMain {


    public static void main(String[] args){
        int testTimes = 1000;
        int sizeMax = 50;
        int range = 50;
        System.out.println("start");

        for (int i = 0; i < testTimes; i++) {
            int[] arr = ArrayUtil.randomArray(sizeMax, range);
            int[] copyArray = ArrayUtil.copyArray(arr);
            QuickSort3_4.quickSort(arr);
            Arrays.sort(copyArray);
            if (!ArrayUtil.isEqual(arr, copyArray)) {
                ArrayUtil.printArr(arr);
                ArrayUtil.printArr(copyArray);
                System.out.println("fuck");
                break;
            }
        }
        System.out.println("end");

    }

}