bfprt算法模板

bfprt

BFPTR算法，又称为中位数的中位数算法，它的最坏时间复杂度为 O(n)。它的算法的思想是修改快速选择算法的主元选取方法，提高算法在最坏情况下的时间复杂度。

重点是：提高算法在最坏情况下的时间复杂度，我们搞算法时候，往往注重使用什么数据结构啦，用什么排序啦，思维停留在使用上，却忽视了算法优化，一般我们优化肯定是找有必要优化的，哪些是有必要优化的，个人认为是挑最差的情况下的和最好情况有很大时间反差的部分优化（拙见大佬勿喷）。

题目：在arr上，找到第K小的数，并返回。K范围是[1,N]，范围不是[0,N-1]

public static int getMinKthByBFPRT(int[] arr, int K) {
    return select(arr, 0, arr.length - 1, K - 1);
}

public static int select(int[] arr, int begin, int end, int i) {
    if (begin == end) {
        return arr[begin];
    }
    int pivot = medianOfMedians(arr, begin, end);
    int[] pivotRange = partition(arr, begin, end, pivot);
    if (i >= pivotRange[0] && i <= pivotRange[1]) {
        return arr[i];
    } else if (i < pivotRange[0]) {
        return select(arr, begin, pivotRange[0] - 1, i);
    } else {
        return select(arr, pivotRange[1] + 1, end, i);
    }
}

public static int medianOfMedians(int[] arr, int begin, int end) {
    int num = end - begin + 1;
    int offset = num % 5 == 0 ? 0 : 1;
    int[] mArr = new int[num / 5 + offset];
    for (int i = 0; i < mArr.length; i++) {
        int beginI = begin + i * 5;
        int endI = beginI + 4;
        mArr[i] = getMedian(arr, beginI, Math.min(end, endI));
    }
    return select(mArr, 0, mArr.length - 1, mArr.length / 2);
}

public static int[] partition(int[] arr, int begin, int end, int pivotValue) {
    int small = begin - 1;
    int cur = begin;
    int big = end + 1;
    while (cur != big) {
        if (arr[cur] < pivotValue) {
            swap(arr, ++small, cur++);
        } else if (arr[cur] > pivotValue) {
            swap(arr, cur, --big);
        } else {
            cur++;
        }
    }
    int[] range = new int[2];
    range[0] = small + 1;
    range[1] = big - 1;
    return range;
}

public static int getMedian(int[] arr, int begin, int end) {
    insertionSort(arr, begin, end);
    int sum = end + begin;
    int mid = (sum / 2) + (sum % 2);
    return arr[mid];
}

public static void insertionSort(int[] arr, int begin, int end) {
    for (int i = begin + 1; i != end + 1; i++) {
        for (int j = i; j != begin; j--) {
            if (arr[j - 1] > arr[j]) {
                swap(arr, j - 1, j);
            } else {
                break;
            }
        }
    }
}

public static void swap(int[] arr, int index1, int index2) {
    int tmp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = tmp;
}