数据结构—堆

•  堆的概念

     堆数据结构是一种数组对象，它可以被视为一棵完全二叉树结构。

     堆结构的二叉树存储是最大堆：每个父节点的都大于孩子节点。

     最小堆：每个父节点的都小于孩子节点。

•   堆的结构

#include <vector>
template<class T>
class Heap
{
public:
    Heap();
    Heap(const T* array, size_t size)
    {
        for (size_t i = 0; i < size; i++)
        {
            _array.push_back(array[i]);
        }
        //建堆
        for (int i = (_array.size() - 2)/2; i >= 0; i--)
        {
            _AdjustDown(i);
        }
    }
    //插入一个数据x到堆中
    void  Push(const T& x)
    {
        _array.push_back(x);
        _AdjustUp(_array.size() - 1);
    }
    //删除堆顶元素
    void Pop()
    {
        assert(_array.size() > 0);
        swap(_array[0], _array[_array.size() - 1]);
        _array.pop_back();
        _AdjustDown(0);
    }
    T& GetTop()
    {
        assert(_array.size() > 0);
        return _array[0];
    }
    //将根节点向下调整
    void _AdjustDown(int root)
    {
        int child = root * 2 + 1;
        while (child < _array.size())
        {
            //比较出左右孩子中大的那个
            if (child + 1 < _array.size() && _array[child + 1] > _array[child])
            {
                child++;
            }
            //与根节点相比
            if (_array[child]>_array[root])
            {
                swap(_array[child], _array[root]);
                root = child;
                child = root * 2 + 1;
            }
            else
            {
                break;
            }
        }
    }
    //一个节点向上调整
    void _AdjustUp(int child)
    {
        int parent = (child - 1) / 2;
        while (child > 0)
        {
            if (_array[child] > _array[parent])
            {
                swap(_array[child], _array[parent]);
                child = parent;
                parent = (child - 1) / 2;
            }
            else
            {
                break;
            }
        }
    }
    void Print()
    {
        for (size_t i = 0; i < _array.size(); ++i)
        {
            cout << _array[i] << " ";
        }
        cout << endl;
    }
    //判断是否为空
    bool Empty()
    {
        return _array.empty();
    }
    size_t Size()
    {
        return _array.size();
    }

public:
    vector<T> _array;
};

• 堆的应用：

 100w个数中找出最大的前K个数

//100w个数中找出最大的前k个数
#define M 1000000
#define N 100
void _Adjustdown(int *Ma, int k, int root)
{
    int child = root * 2 + 1;
    while (child < k)
    {
        if ((child + 1 )< k&&Ma[child + 1] < Ma[child])
        {
            child++;
        }
        if (Ma[child] < Ma[root])
        {
           swap(Ma[child], Ma[root]);
           root = child;
           child = root * 2 + 1;
        }
        else
        {
            break;
        }
    }
   
}
int* FindMaxKNum(int* array,int *Ma,int size,int k)
{
    for (int i = 0; i < k; i++)
    {
        Ma[i] = array[i];
    }

    for (int i = (k - 2) / 2; i >= 0; --i)
    {
        _Adjustdown(Ma, k, i);
    }
    for (int i = k; i < size; ++i)
    {
        if (array[i] > Ma[0])
        {
            Ma[0] = array[i];
            _Adjustdown(Ma, k, 0);
        }
    }
    return Ma;
}
void TestFindPreKNum()
{
    int *array = new int[M];
    int *Ma = new int[N];
    for (int i = 0; i < M; i++)
    {
        array[i] = i;
    }

    int* ret = FindMaxKNum(array, Ma, M,N);
    for (int i = 0; i < N; ++i)
    {
        cout << *(ret + i) << "  ";
    }
    cout << endl;
    delete []array;
    delete []Ma;

}