bfprt 算法
在无序数组中找到第K小的数
在无序数组中找到第K小的数,时间复杂度要求是O(n).
解法一 改写快排
再学习bfprt算法之前，先看下，如何通过改写快排的方式实现，时间复杂是O(n)的算法。
什么是快排：快速排序（Quick Sort）是一种高效的排序算法，它基于分治策略和递归实现。它的基本思想是将一个数组分成两个子数组，然后对这两个子数组分别进行排序，最终将两个有序的子数组合并成一个有序的数组。
使用任何关于排好序在拿值的方法都是不符合要求的，因此排序算法，最好的时间复杂度也是N * log N ；是不符合要求的，即使语言本身实现的也不符合要求。
这题我们就是借助快排里的分层的思想，来实现复杂度是O(n)，快排中会随机选中一个数字，然后将数组分成三部分，一部分是大于当前数字的，一部分等于当前数字的，一部分小于当前数字的，有了这三层，那么数组整体上就是有序的，在小范围内是无序的，根据整体有序，那么我们就可以抛掉两部分，只在符合要求的那一部分内继续去查找，这样就形成了剪枝的效果，使其复杂度降到O(n);
代码演示
java
/**
* 查找第k 小的数
* @param array
* @param k
* @return
*/
public static int minKth2(int[] array, int k) {
//为了不改变原数组
int[] arr = copyArray(array);
return process2(arr, 0, arr.length - 1, k - 1);
}
/**
* 复制数组，
* @param arr
* @return
*/
public static int[] copyArray(int[] arr) {
int[] ans = new int[arr.length];
for (int i = 0; i != ans.length; i++) {
ans[i] = arr[i];
}
return ans;
}
/**
* // arr 第k小的数
* // process2(arr, 0, N-1, k-1)
* // arr[L..R] 范围上，如果排序的话(不是真的去排序)，找位于index的数
* // index [L..R]
* @param arr
* @param L
* @param R
* @param index
* @return
*/
public static int process2(int[] arr, int L, int R, int index) {
if (L == R) { // L = =R ==INDEX
return arr[L];
}
// 随机选中一个数进行分层
int pivot = arr[L + (int) (Math.random() * (R - L + 1))];
int[] range = partition(arr, L, R, pivot);
//刚好在选中的数字范围内，直接返回
if (index >= range[0] && index <= range[1]) {
return arr[index];
} else if (index < range[0]) {
//小于去左边继续搜
return process2(arr, L, range[0] - 1, index);
} else {
//大于去右边搜
return process2(arr, range[1] + 1, R, index);
}
}
/**
* 分层 小于在左边，大于在右边
* 返回数组， 当前选中数字所在位置的左右边界
* @param arr
* @param L
* @param R
* @param pivot
* @return
*/
public static int[] partition(int[] arr, int L, int R, int pivot) {
int less = L - 1;
int more = R + 1;
int cur = L;
while (cur < more) {
if (arr[cur] < pivot) {
swap(arr, ++less, cur++);
} else if (arr[cur] > pivot) {
swap(arr, cur, --more);
} else {
cur++;
}
}
return new int[] { less + 1, more - 1 };
}
/**
* 位置交换
* @param arr
* @param i1
* @param i2
*/
public static void swap(int[] arr, int i1, int i2) {
int tmp = arr[i1];
arr[i1] = arr[i2];
arr[i2] = tmp;
}bfprt 算法
bfprt 算法和上面改写快排的方法实际是类似的，区别在于进行数据分层时，我们改写快排中，是随机选中一个数字进行分层，这样是有一个问题，复杂度会根据选中数字的优劣变化，时间复杂度是O(n)是指其会收敛于O(n).
bfprt 算法，是要根据一个规则来选取用来分层的数，使其复杂度是个固定值，不是数学法证明收敛于某个值，具体 规则如下：
1.数组中每五个元素分成一组，最后不够五个的，单独算一组
2.每个小组的元素，进行排序，
3.选取每组排序后的中间数字，组成一个新的小组
4.在把新小组的数字排序后，选择中间的数字，
通过这几步下来，选取的数字，就很接近中间数字了，这样就保证，每次都能舍弃将近一半的数字，从而让复杂度变成固定值，
代码演示
java
public class Demo22 {
/**
* bfprt 算法
* @param array
* @param k
* @return
*/
public int minKth3(int[] array, int k) {
int[] arr = copyArray(array);
return bfprt(arr, 0, arr.length - 1, k - 1);
}
// arr[L..R] 如果排序的话，位于index位置的数，是什么，返回
public int bfprt(int[] arr, int L, int R, int index) {
if (L == R) {
return arr[L];
}
// L...R 每五个数一组
// 每一个小组内部排好序
// 小组的中位数组成新数组
// 这个新数组的中位数返回
int pivot = medianOfMedians(arr, L, R);
int[] range = partition(arr, L, R, pivot);
if (index >= range[0] && index <= range[1]) {
return arr[index];
} else if (index < range[0]) {
return bfprt(arr, L, range[0] - 1, index);
} else {
return bfprt(arr, range[1] + 1, R, index);
}
}
/**
* 分层 大的放左边，等于放中间，小于放右边。
* @param arr
* @param L
* @param R
* @param pivot
* @return
*/
public int[] partition(int[]arr,int L,int R,int pivot){
int more = L - 1;
int less = R + 1;
int cur = L;
while (cur < less){
if (arr[cur] > pivot){
swap(arr,++more,cur++);
} else if (arr[cur] < pivot) {
swap(arr,cur,--less);
}else{
cur++;
}
}
return new int[]{more + 1, less - 1};
}
// arr[L...R] 五个数一组
// 每个小组内部排序
// 每个小组中位数领出来，组成marr
// marr中的中位数，返回
public int medianOfMedians(int[] arr, int L, int R) {
int size = R - L + 1;
int offset = size % 5 == 0 ? 0 : 1;
int[] mArr = new int[size / 5 + offset];
for (int team = 0; team < mArr.length; team++) {
int teamFirst = L + team * 5;
// L ... L + 4
// L +5 ... L +9
// L +10....L+14
mArr[team] = getMedian(arr, teamFirst, Math.min(R, teamFirst + 4));
}
// marr中，找到中位数
// marr(0, marr.len - 1, mArr.length / 2 )
return bfprt(mArr, 0, mArr.length - 1, mArr.length / 2);
}
public int getMedian(int[] arr, int L, int R) {
insertionSort(arr, L, R);
return arr[(L + R) / 2];
}
public void insertionSort(int[] arr, int L, int R) {
for (int i = L + 1; i <= R; i++) {
for (int j = i - 1; j >= L && arr[j] > arr[j + 1]; j--) {
swap(arr, j, j + 1);
}
}
}
/**
* 插入排序
* @param arr
* @return
*/
public int[] copyArray(int[] arr) {
int[] ans = new int[arr.length];
for (int i = 0; i != ans.length; i++) {
ans[i] = arr[i];
}
return ans;
}
/**
* 交换
* @param nums
* @param i
* @param j
*/
public void swap(int[]nums,int i,int j){
int temp = nums[i];
nums[i] = nums[j];
nums[j] = temp;
}
}