在线编程（二）

1.给定一个无序数组，找出其中最小的k个数。
思路：建立一个k个数的最大堆，则这个堆的堆顶为最大的数，依旧与剩下的数比较，若小于堆顶，则互换并维护这个堆。得到的这个堆即为最小的k个数。

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

//建立k个数的最大堆
void heapinsert(vector<int> &arr,int value,int index)
{
    arr.push_back(value);
    while(index!=0)
    {
        int parent=(index-1)/2;
        if(arr[parent]<arr[index])
        {
            int temp=arr[parent];
            arr[parent]=arr[index];
            arr[index]=arr[parent]; 
            index=parent;
        }
        else
        {
            break;
        }
    }
}

//维护堆，若堆顶元素小于左右孩子则交换，并向下维护
void heapify(vector<int> &arr,int index,int heapsize)
{
    int left=index*2+1;
    int right=index*2+2;
    int largest=index;
    while(left<heapsize)
    {
        if(arr[left]>arr[index])
            largest=left;
        if(right<heapsize && arr[right]>arr[largest])
            largest=right;
        if(largest!=index)
        {
            int temp=arr[index];
            arr[index]=arr[largest];
            arr[largest]=temp;  

        }
        else
        {
            break;
        }
        index=largest;
        left=index*2+1;
        right=index*2+2;
    }
}

//该算法的时间复杂度为N*logk
vector<int> getMink(vector<int> arr, int k)
{
    vector<int> heapk;
    if(k<1 &&k >arr.size())
        return heapk;
    for(int i=0;i<k;i++)
        heapinsert(heapk,arr[i],i);
    for(int i=k;i<arr.size();i++)
        if(arr[i]<heapk[0])
        {
            heapk[0]=arr[i];
            heapify(heapk,0,k);
        }
        return heapk;
}


int main()
{
    vector<int> arr;
    arr.push_back(32);
    arr.push_back(22);
    arr.push_back(27);
    arr.push_back(14);
    arr.push_back(37);
    arr.push_back(11);
    arr.push_back(8);
    vector<int> res;

    res=getMink(arr,3);

    for(int i=0;i<res.size();i++)
    {
        cout<<res[i]<<" ";
    }
}

思路2：BFPRK算法（线性查找算法又称中位数的算法）
即找出中位数的中位数作为一趟快排的pviot，快排后如果刚好是第k为则返回这个数，如果不是，在左边/右边继续。

#include <iostream>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include <algorithm>

using namespace std;
const int N = 10005;

int a[N];

//插入排序
void InsertSort(int a[], int l, int r)
{
    for(int i = l + 1; i <= r; i++)
    {
        if(a[i - 1] > a[i])
        {
            int t = a[i];
            int j = i;
            while(j > l && a[j - 1] > t)
            {
                a[j] = a[j - 1];
                j--;
            }
            a[j] = t;
        }
    }
}

//寻找中位数的中位数
int FindMid(int a[], int l, int r)
{
    if(l == r) return a[l];
    int i = 0;
    int n = 0;
    for(i = l; i < r - 5; i += 5)
    {
        InsertSort(a, i, i + 4);
        n = i - l;
        swap(a[l + n / 5], a[i + 2]);
    }

    //处理剩余元素
    int num = r - i + 1;
    if(num > 0)
    {
        InsertSort(a, i, i + num - 1);
        n = i - l;
        swap(a[l + n / 5], a[i + num / 2]);
    }
    n /= 5;
    if(n == l) return a[l];
    return FindMid(a, l, l + n);
}

//寻找中位数的所在位置
int FindId(int a[], int l, int r, int num)
{
    for(int i = l; i <= r; i++)
        if(a[i] == num)
            return i;
    return -1;
}

//进行划分过程
int Partion(int a[], int l, int r, int p)
{
    swap(a[p], a[l]);
    int i = l;
    int j = r;
    int pivot = a[l];
    while(i < j)
    {
        while(a[j] >= pivot && i < j)
            j--;
        a[i] = a[j];
        while(a[i] <= pivot && i < j)
            i++;
        a[j] = a[i];
    }
    a[i] = pivot;
    return i;
}

int BFPTR(int a[], int l, int r, int k)
{
    int num = FindMid(a, l, r);    //寻找中位数的中位数
    int p =  FindId(a, l, r, num); //找到中位数的中位数对应的id
    int i = Partion(a, l, r, p);

    int m = i - l + 1;
    if(m == k) return a[i];
    if(m > k)  return BFPTR(a, l, i - 1, k);
    return BFPTR(a, i + 1, r, k - m);
}

int main()
{
    int n, k;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
        scanf("%d", &a[i]);
    scanf("%d", &k);
    printf("The %d th number is : %d\n", k, BFPTR(a, 0, n - 1, k));
    for(int i = 0; i < n; i++)
        printf("%d ", a[i]);
    puts("");
      return 0;
}