数据结构--堆

【1】什么是堆？

堆是一种特殊的完全二叉树（关于完全二叉树可以参见随笔《树》）。

堆分为两种：最大堆和最小堆

最大堆只需要满足父节点大于两个子节点，而子节点之间没有要求。

最小堆只需要满足父节点小于两个子节点，而子节点之间没有要求。

那么，既然作为一棵完全二叉树，每层中的节点应该是从左到右填满的。

如果一个节点没有左儿子，那么它一定也没有右儿子。

并且在第N层中如果存在节点，肯定是由左向右依次排列，而且第N-1层必须是填满的。

【2】堆的实现

最小堆的实现代码如下：

#include <iostream>
#include <assert.h>
#include <windows.h>
#include <time.h>
#include <iomanip>
using namespace std;

template<typename Type>
class  Heap
{
public:
    virtual bool Insert(const Type &x) = 0;
    virtual bool Remove(Type &x) = 0;
};
template<typename Type>
class MinHeap
{
private:
    enum { DEFAULTSIZE = 10 };
    Type *heap;
    int  Cursize;
    int  Maxsize;
private:
    void  FilterDown(const int pos,const int end);
    void  FilterUp(const int  start);
public:
    MinHeap(int sz = DEFAULTSIZE);
    MinHeap(int ar[], int n);
    MinHeap(const  MinHeap<Type>  &mh);
    MinHeap<Type> & operator=(const  MinHeap<Type> &mh);
    ~MinHeap();
    bool Insert(const Type &x);
    bool Remove(Type &x);
    bool IsEmpty() const;
    bool IsFull() const;
    void MakeEmpty();
public:
    template<class Type>
    friend ostream &operator<<(ostream  &out,MinHeap<Type> &mh);
};

template<typename  Type>
MinHeap<Type>::MinHeap(int sz)
{
    Maxsize = sz > DEFAULTSIZE ? sz : DEFAULTSIZE;
    heap = new  Type[Maxsize+1];
    assert(heap != NULL);
    memset(heap, 0, sizeof(Type) * (Maxsize+1));
    Cursize = 0;
}
template<typename  Type>
MinHeap<Type>::MinHeap(int ar[], int n)
{
    Cursize = Maxsize = n;
    heap = new Type[Maxsize+1];
    assert(heap != NULL);
    for (int i = 0; i < Maxsize; i++)
    {
        heap[i+1] = ar[i];
    }
    int pos = Cursize/2;
    while (pos > 0)
    {
        FilterDown(pos, Cursize);
        --pos;
    }
}
template<typename Type>
MinHeap<Type>::MinHeap(const MinHeap<Type> &mh)
{
    Cursize = mh.Cursize;
    Maxsize = mh.Maxsize;
    heap = new Type[Maxsize+1];
    assert(heap != NULL);
    memcpy(heap, mh.heap, sizeof(Type) * (Cursize+1));
}
template<typename Type>
MinHeap<Type> & MinHeap<Type>::operator=(const MinHeap<Type> &mh)
{
    if (this != &mh)
    {
        Cursize = mh.Cursize;
        Maxsize = mh.Maxsize;
        delete []heap;
        heap = new Type[Maxsize+1];
        assert(heap != NULL);
        memcpy(heap, mh.heap, sizeof(Type) * (Cursize+1));
    }
    return *this;
}
template<typename Type>
MinHeap<Type>::~MinHeap()
{
    if (heap != NULL)
    {
        delete []heap;
        heap = NULL;
    }
    Cursize = Maxsize = 0;
}
template<typename Type>
void MinHeap<Type>::FilterDown(const int pos, const int end)
{
    int i = pos, j = i*2; // j是i的左子女
    heap[0] = heap[i];
    while (j <= end)
    {
        if (j < end && heap[j] > heap[j+1])    // 取孩子中大者
        {
            ++j;
        }
        if (heap[j] < heap[0])    // 父节点 大于 子女节点的最大者
        {
            heap[i] = heap[j]; // 对换
            i = j;
            j = i*2;
        }
        else
        {
            break;
        }
    }
    heap[i] = heap[0];
}
template<typename Type>
void MinHeap<Type>::FilterUp(const int  start)
{
    int i = start, j = i/2; // j是i的双亲
    heap[0] = heap[i];
    while (i > 1)
    {
        if (heap[j] > heap[0])
        {
            heap[i] = heap[j];
            i = j;
            j = i/2;
        }
        else
        {
            break;
        }
    }
    heap[i] = heap[0];
}
template<typename Type>
bool MinHeap<Type>::Insert(const Type &x)
{
    if (Cursize < Maxsize)
    {
        heap[++Cursize] = x;
        FilterUp(Cursize);
        return true;
    }

    return  false;
}
template<typename Type>
bool MinHeap<Type>::Remove(Type &x)
{
    if (Cursize > 0)
    {
        x = heap[1];
        heap[1] = heap[Cursize--];
        FilterDown(1, Cursize);
        return true;
    }

    return false;
}
template<typename Type>
bool MinHeap<Type>::IsEmpty() const
{
    return  0 == Cursize;    
}
template<typename Type>
bool MinHeap<Type>::IsFull() const
{
    return Cursize == Maxsize;
}
template<typename Type>
void MinHeap<Type>::MakeEmpty()
{
    Cursize = 0;
}
template<typename  Type>
ostream & operator<<(ostream &out, MinHeap<Type> &mh)
{
    while (!mh.IsEmpty())
    {
        int temp;
        mh.Remove(temp);
        out << temp << setw(5);
    }
    out << endl;
    return out;
}

Good  Good  Study, Day  Day  Up.

顺序  选择  循环  总结