Top_K问题，堆排序

Top_K问题
简述：在大量数据中选出K个最大的或最小的。
以取K个最大数为例：
具体思路：
1. 将给定的数据的前K个元素压入到vector空间，对这K个数进行向下调整建小堆;
2. 再将堆顶元素和数组的其他元素进行比较，当堆顶元素小于数组中所取元素时，将所取数组元素入堆;
3. 再进行调整，直到数组所有元素都依次进行比较。

//仿函数比较
template<class T>
struct Less
{
    bool operator()(const T& l, const T& r)
    {
        return l < r;
    }
};
template<class T>
struct Greator
{
    bool operator()(const T& l, const T& r)
    {
        return l > r;
    }
};

template<class T,class Compare >
class K_Heap
{
public:
    K_Heap()
    {}
    K_Heap(T* arr, size_t size, size_t k)
    {
        assert(k < size);
        _a.reserve(k);
        for (size_t i = 0; i < k; ++i)
        {
            _a.push_back(arr[i]);
        }
        for (size_t i = (k - 2) / 2; i > 0; --i)
        {
            AdjustDown(k, i);
        }
        for (size_t i = 0; i < size; ++i)
        {
            if (_a[0] < arr[i])
            {
                _a[0] = arr[i];
                AdjustDown(k, 0);
            }
        }
        for (size_t i = 0; i < k; ++i)
        {
            cout << _a[i] << " ";
        }
        cout << endl;
    }
protected:
    void AdjustDown(size_t k, size_t parent)
    {
        Compare com;
        size_t child = parent * 2 + 1;
        while (child < _a.size())
        {
            if (child + 1 < _a.size() && com(_a[child+1], _a[child]))
            {
                ++child;
            }
            if (com(_a[child], _a[parent]))
            {
                swap(_a[child], _a[parent]);
                parent = child;
                child = parent * 2 + 1;
            }
            else
            {
                break;
            }
        }
    }
private:
    vector<T> _a;
};

---

堆排序：

具体思路：
1. 将给定的数组压入vector中，对其进行向下调整调节为大堆或者小堆；
2.取出最小的数和最大数进行交换；
3.再次进行调整的时候元素的个数应该减一，不用算最后一个元素（因为最后一个不是最大的数就是最小的数）；
4.直到所有的数都依次进行了比较。

//堆排序
template<class T>
struct Less
{
    bool operator()(const T& l, const T& r)
    {
        return l < r;
    }
};
template<class T>
struct Greator
{
    bool operator()(const T& l, const T& r)
    {
        return l > r;
    }
};
template<class T, class Compare>
class Sort_Heap
{
public:
    Sort_Heap()
    {}
    Sort_Heap(T* arr, size_t size)
    {
        _a.reserve(size);
        for (size_t i = 0; i < size; ++i)
        {
            _a.push_back(arr[i]);
        }
        for (int i = (size - 2) / 2; i >= 0; --i)
        {
            AdjustDown(size, i);
        }
    }
    void AdjustDown(size_t size, size_t parent)
    {
        Compare com;
        size_t child = parent * 2 + 1;
        while (child < size)
        {
            if (child + 1 < size && com(_a[child + 1], _a[child]))
            {
                ++child;
            }
            if (com(_a[child], _a[parent]))
            {
                swap(_a[child], _a[parent]);
                parent = child;
                child = parent * 2 + 1;
            }
            else
            {
                break;
            }
        }
    }
    void _Sort_Heap(size_t size)
    {
        size_t end = size - 1;
        while (end > 0)
        {
            swap(_a[0], _a[end]);
            AdjustDown(end, 0);
            --end;
        }
    }
    void Print()
    {
        for (size_t i = 0; i < _a.size(); ++i)
        {
            cout << _a[i] << " ";
        }
        cout << endl;
    }
private:
    vector<T> _a;
};