第K小的数BFPRT算法

介绍

BFPRT是解决求一个数组中第K小的数的算法，可以时间O(N)的时间复杂度，而使用排序求第K小的数的算法的时间复杂度为O(NlogN)，因此BFPRT算法更加高效

思想

（1）分组：将原数组每五个数分为一组，不足5个数的单分一组
（2）组内排序：每个小组从小到大进行排序
（3）选取每个分组中的中位数组成一个中位数数组
（4）求中位数数组的中位数
（5）将第四步求出的中位数作为划分值，对原数组进行划分，小于的放左边，等于的放中间，大于的放右边

getMid函数

组内排序，并返回该组的中位数

int getMid(int arr[], int begin, int end){
    sort(arr+begin,arr+end+1);
    return arr[begin + (end - begin)/2];
}

midOfMids函数

实现分组，生成中位数数组，并返回中位数数组的中位数

int midOfMids(int arr[], int begin, int end){
    int size = end-begin+1;
    int groupSzie = (size - 1) / 5 + 1;
    int *midArr = new int[groupSzie];
    int L = begin;
    int R = L + 4 > end ? end : L + 4;
    for(int i = 0; i < groupSzie; i++){
        midArr[i] = getMid(arr, L, min(R, end));
        L = R + 1;
        R = L + 4 > end ? end : L + 4;
    }
    return bfprt(midArr, 0, groupSzie-1, groupSzie/2);

partition函数

按照k值对数组进行划分

int *partition(int arr[], int begin, int end, int k){
    int L = begin-1;
    int R = end+1;
    int cur = begin;
    while(cur < R){
        if(arr[cur] < k){
            swap(arr, ++L, cur++);
        }else if(arr[cur] == k){
            cur++;
        }else{
            swap(arr, --R, cur);
        }
    }
    return new int [2] {L + 1, R - 1};
}

bfprt函数

实现整个流程，没有单独调用midOfMids，直接在函数体内实现

int bfprt(int arr[], int begin, int end, int k){
    if(begin == end)
        return arr[begin];
    int size = end - begin + 1;
    int groupSzie = (size - 1) / 5 + 1; //向上取整
    int *midArr = new int[groupSzie];
    int L = begin;
    int R = L + 4 > end ? end : L + 4;
    for(int i = 0; i < groupSzie; i++){
        midArr[i] = getMid(arr, L, min(R, end));
        L = R + 1;
        R = L + 4 > end ? end : L + 4;
    }
    int midNum = bfprt(midArr, 0, groupSzie - 1, groupSzie/2);
    int *p = partition(arr, begin, end, midNum);
    if(k < p[0])
        return bfprt(arr, begin, p[0] - 1, k);
    else if(k > p[1])
        return bfprt(arr, p[1] + 1, end, k);
    return arr[k];
}

完整代码

#include <iostream>
#include <algorithm>
using namespace std;

void swap(int arr[], int i, int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

int *partition(int arr[], int begin, int end, int k){
    int L = begin-1;
    int R = end+1;
    int cur = begin;
    while(cur < R){
        if(arr[cur] < k){
            swap(arr, ++L, cur++);
        }else if(arr[cur] == k){
            cur++;
        }else{
            swap(arr, --R, cur);
        }
    }
    return new int [2] {L + 1, R - 1};
}

int getMid(int arr[], int begin, int end){
    sort(arr+begin,arr+end+1);
    return arr[begin + (end - begin)/2];
}

int bfprt(int arr[], int begin, int end, int k){
    if(begin == end)
        return arr[begin];
    int size = end - begin + 1;
    int groupSzie = (size - 1) / 5 + 1; //向上取整
    int *midArr = new int[groupSzie];
    int L = begin;
    int R = L + 4 > end ? end : L + 4;
    for(int i = 0; i < groupSzie; i++){
        midArr[i] = getMid(arr, L, min(R, end));
        L = R + 1;
        R = L + 4 > end ? end : L + 4;
    }
    int midNum = bfprt(midArr, 0, groupSzie - 1, groupSzie/2);
    int *p = partition(arr, begin, end, midNum);
    if(k < p[0])
        return bfprt(arr, begin, p[0] - 1, k);
    else if(k > p[1])
        return bfprt(arr, p[1] + 1, end, k);
    return arr[k];
}

int main()
{
    int n, k;
    cin >> n >> k;
    int *arr = new int[n];
    for(int i = 0; i < n; i++)
        cin >> arr[i];
    cout << bfprt(arr, 0, n-1, k-1) << endl;
    return 0;
}

测试代码

使用sort函数，即使用排序的方法求第K小的数，然后随机生成一个一维数组，找第K小的数，与BFPRT算法进行比较，以测试BFPRT算法的正确性

#include <iostream>
#include <algorithm>
using namespace std;

void swap(int arr[], int i, int j){
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

int *partition(int arr[], int begin, int end, int k){
    int L = begin-1;
    int R = end+1;
    int cur = begin;
    while(cur < R){
        if(arr[cur] < k){
            swap(arr, ++L, cur++);
        }else if(arr[cur] == k){
            cur++;
        }else{
            swap(arr, --R, cur);
        }
    }
    return new int [2] {L + 1, R - 1};
}

int getMid(int arr[], int begin, int end){
    sort(arr+begin,arr+end+1);
    return arr[begin + (end - begin)/2];
}

int bfprt(int arr[], int begin, int end, int k){
    if(begin == end)
        return arr[begin];
    int size = end - begin + 1;
    int groupSzie = (size - 1) / 5 + 1; //向上取整
    int *midArr = new int[groupSzie];
    int L = begin;
    int R = L + 4 > end ? end : L + 4;
    for(int i = 0; i < groupSzie; i++){
        midArr[i] = getMid(arr, L, min(R, end));
        L = R + 1;
        R = L + 4 > end ? end : L + 4;
    }
    int midNum = bfprt(midArr, 0, groupSzie - 1, groupSzie/2);
    int *p = partition(arr, begin, end, midNum);
    if(k < p[0])
        return bfprt(arr, begin, p[0] - 1, k);
    else if(k > p[1])
        return bfprt(arr, p[1] + 1, end, k);
    return arr[k];
}

int randSize;

//生成随机数组
template <class T>
T* creatArr(int size, int value){
    //srand((unsigned)time(NULL));
    srand(rand());
    randSize = rand()%(size+1)+1;
    T *arr = new T [randSize];
    for(int i = 0; i < randSize; i++){
        arr[i] = rand()%(value+1) - rand()%(value+1);
        cout << arr[i] << " ";
    }
    cout << endl;
    return arr;
}

//输出数组
template<class T>
void outputArr(T arr[], int size){
    for(int i = 0; i < size; i++){
        cout << arr[i] << " ";
    }
    cout << endl;
}

//拷贝数组
template<class T>
T* copyArr(T arr[], int size){
    T* newArr = new T [size];
    for(int i = 0; i < size; i++){
        newArr[i] = arr[i];
    }
    return newArr;
}

int main(){
    int testTime = 50000;
    int size = 10, value = 1000;
    while(testTime--){
        int *arr = creatArr<int>(size, value);
        srand(rand());
        int k = rand() % randSize + 1;
        int my = bfprt(arr, 0, randSize-1, k-1);
        sort(arr, arr+randSize);
        int res = arr[k-1];
        if(my != res){
            cout << "Error!" << endl;
            break;
        }else{
            cout << "Nice!" << endl;
        }
    }
}