数组------最小的k个数

问题描述：　求数组中的最小k个数。
分析：
<1>使用线性选择算法来快速实现(O(n))，具体来说就是借助快速排序的思想，把数组分为比主元v小的部分s1，和比主元v大的部分s2。
１．若k <= |s1|，则第k小的元素在s1，就递归的对s1进行相同的操作。
２．若k = |s1| + 1，那就表示主元就是第k小的元素，那就结束算法，此时数组的前k个元素就是要找的最小k个元素。
３．若k > |s1| + 1，则第k小的元素在s2中，那就递归的对s2进行相同操作。
４．若数组太短，就直接使用插入排序即可。

void QuickSelect(int arr[], int k, int left, int right)
{
    if(arr == NULL || left < 0 || right < left)
    {
        cout << "something error!" << endl;
        exit(1)
    }

    if(left <= right - 3)
    {
        int i, j;
        int mid = left + (right - left)/2 ;
        SortFirstMidLast(arr, left, mid, right);
        swap(arr[mid], arr[right - 1]);
        int index = right - 1;
        int indexValue = arr[index];
        i = left + 1;
        j = right - 2;
        for(;;)
        {
            while(arr[i] < indexValue)
                i += 1;
            while(arr[j] > indexValue)
                j -= 1;
            if(i < j)
                swap(arr[i], arr[j]);
            else 
                break;
        }
        swap(arr[i], arr[index]);
        if(k <= i)
            QuickSelect(arr, k, left, i - 1);
        else if(k > i + 1)
            QuickSelect(arr, k, i + 1, right);
    }
    else
        InsertSort(arr, left, right);
}

void SortFirstMidLast(int arr[], int first, int mid, int end)
{
    if(arr[first] > arr[mid])
        swap(arr[first], arr[mid]);
    if(arr[mid] > arr[end])
        swap(arr[mid], arr[end]);
    if(arr[first] > arr[mid])
        swap(arr[first], arr[mid]);
}

void InsertSort(int arr[], int left, int right)
{
    for(int un = left + 1; un <= right; un++)
    {
        int tmp = arr[un];
        int lcoal = un;
        while(local > 0 && arr[local - 1] > tmp)
        {
            arr[local] = arr[local - 1];
            local--;
        }
        arr[local] = tmp;
    }
}

<2> 上述方法需要改变原来的数组，若要使得原来数组不变，则可以使用一个大小为k的最大堆，先取数组前k个数入堆并排序，然后从数组的k+1个元素开始，每次与堆顶元素p进行比较，若arr[k+1] >= p，则继续比较下一个元素。若k[k+1] < p，则删除堆顶元素，并将arr[k+1]插入堆中并将堆排序，然后继续比较arr[k+2]…(此方法不会改变原始数组，并且适合处理海量数据。其时间复杂度为O(nlogk)。//实现时，可以用一个长为k的数组来实现一个最大堆)

void SortByHeap(int *arr, int *heap, int len)
{
    if(len < N)
    {
        cout << "the array too short!" << endl;
        return;
    }
    for(int i = 0; i < N; i++)  //将数组前N个元素放入堆中
        heap[i] = arr[i];

    for(int index = N/2; index >= 0; index--)  //堆排序
    {
        heapRebuild(index, heap, N);
    }
    for(int i = N; i < len; i++)  //从第N+1个元素开始一一对比
    {
        if(arr[i] < heap[0])
        {
            heap[0] = arr[i];
            for(int index = N/2; index >= 0; index--)  //堆排序
            {
                heapRebuild(index, heap, N);
            }
        }
    }
 }

void heapRebuild(int rootIndex, int *arr, int count) //创建大顶堆
{
    if(rootIndex * 2 + 1 <= count - 1)  //有左孩子结点
    {
        int largerChildIndex = rootIndex * 2 + 1;
        if(largerChildIndex + 1 <= count - 1)  //有右孩子结点
        {//获得孩子结点中的较大的那个的下标
            int rightIndex = largerChildIndex + 1;
            if(arr[rightIndex] > arr[largerChildIndex])
                largerChildIndex = rightIndex;  
        }
        if(arr[rootIndex] < arr[largerChildIndex])
        {//若孩子结点中较大的那个大于了根节点，那就交换它们，并递归的对每一层进行比较
            swap(arr[rootIndex], arr[largerChildIndex]);
            heapRebuild(largerChildIndex, arr, count);   //对每一层都进行相同操作
        }
    }
}

<3> 使用基于红黑树的multiset来实现。

typedef multiset<int, greate<int> > intSet;
typedef multiset<int, greate<int> >::iterator setIterator;

void getLeastNumbers(const vector<int>& data, intSet& leastNumbers, int k){
    leastNumbers.clear();
    if(k < 1 || data.size() < k)
        return ;
    vector<int>::const_iterator iter = data.begin();
    for(; iter != data.end(); ++iter){
        if(leastNumbers.size() < k){
            leastNumbers.insert(*iter);
        }else{
            setIterator iterGreat = leastNumbers.begin();
            if(*iter < *(leastNumbers.begin())){
                leastNumber.erase(iterGreat);//删除iterGreat位置上的元素
                leastNumber.insert(*iter);
            }
        }
    }
}