寻找最小的k个数（大顶堆方法）

题目描述：查找最小的k个元素，输入n个整数，输出其中最小的k个。

一般的排序方法，如快排，时间复杂度为O（n*logn+k）;

大顶堆方法，时间复杂度为O（k+（n-k）*logk）;

如果建立k个元素的最小堆的话，那么其空间复杂度势为O（N），而建立k个元素的最大堆的空间复杂度为O（k）;

当面对海量数据处理的时候，大顶堆的方法是较为靠谱的，并且可以在面试时短时间内完成代码。

class Solution {
public:
    void Swap(int &a,int &b)
    {
        a^=b;
        b^=a;
        a^=b;
    }

    void HeapAdjust(vector<int> &input,int i,int k)
    {
        int max = i;
        int leftchild = 2*i;
        int rightchild = 2*i+1;

        if(i<=k/2)
        {
            if(input[leftchild] > input[max] && leftchild <= k)
            {
                max = leftchild;
            }
            if(input[rightchild] > input[max] && rightchild <= k)
            {
                max = rightchild;
            }
            if(max!=i)
            {
                Swap(input[i],input[max]);
                HeapAdjust(input,max,k);
            }
        }
    }

    void BuildHeap(vector<int> &input,int k)
    {
        for(int i = k/2;i >0;i--)
        {
            HeapAdjust(input,i,k);
        }
    }
    
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int> result;
        vector<int> temp;
        int len = input.size();
        if(k>len)
            return result;
        
        temp.push_back(0);
        for(int i = 0;i < len;i++)
        {
            temp.push_back(input[i]);
        }

        BuildHeap(temp,k);

        for(int i = k+1;i <= len;i++)
        {
            if(temp[i] < temp[1])
            {
                temp[1] = temp[i];
                HeapAdjust(temp,1,k);
            }
        }
        
        for(int i = 0;i < k;i++)
        {
            result.push_back(temp[i+1]);
        }
        return result;
    }
};

PS：类似快速排序的partition过程，时间复杂度可以做到O（N）。