堆Heap

最小堆的类声明:

template<class ElementType>
class MinHeap
{
public:
    MinHeap(ElementType array[], int maxHeapSize);
    ~MinHeap() { delete [] heap; }
    int insertHeap(const ElementType &item);                    // 向堆中插入一个元素
    int removeHeap(ElementType &item);                          // 堆是否为空
    bool isEmpty();         
private:            
    ElementType *heap;                                          // 存储堆的数组
    int currentLength;                                          // 堆的当前长度
    int maxHeapSize;                                            // 堆的最大存储空间
    void siftDown(int nodeIndex);                               // 从结点号nodeIndex开始自顶向下调整堆
    void siftUp(int nodeIndex);                                 // 从结点号nodeIndex开始自底向上调整堆
};

数据节点定义:

/*
 * 定义堆的顺序存储类型
 */
struct HeapSequence
{
    ElementType *heap;          // 定义指向存放堆的数组指针
    int currentLength;          // 定义堆的长度
    int MAXSIZE;                // 堆数组的最大空间
};

基本操作:

/*
 * 初始化堆
 */
void initHeap(HeapSequence &HBT, int maxSize)
{
    if(maxSize <= 0) {
        cout << "The real parameter 'maxSize' is invalid!
";
        exit(-1);
    }
    HBT.heap = new ElementType[maxSize];
    if(HBT.heap == NULL) {
        cout << "Allocate memory failed!
";
        exit(-1);
    }
    HBT.MAXSIZE = maxSize;
    HBT.currentLength = 0;                                          // 置堆为空
}

/*
 * 检查堆是否为空
 */
bool isEmpty(HeapSequence &HBT)
{
    return HBT.currentLength == 0;
}

/*
 * 清除堆
 */
void clearHeap(HeapSequence &HBT)
{
    delete HBT.heap;
    HBT.heap = NULL;
    HBT.currentLength = 0;
}

/*
 * 向堆中插入一个元素
 */
void insertHeap(HeapSequence &HBT, ElementType item)
{
    /* 处理堆空间满的情况 */
    if(HBT.currentLength == HBT.MAXSIZE) {    
        ElementType *newArray = new ElementType[HBT.MAXSIZE * 2]);      // 存储空间扩大一倍
        if(newArray == NULL) {
            cout << "Allocate memory failed!
";
            exit(-1);
        }
        for(int index = 0; index < HBT.MAXSIZE; ++index)                // 将堆中原有数据放入新的存储空间
            newArray[index] = HBT.heap[index];
        delete HBT.heap;                                                // 释放原有空间
        HBT.heap = newArray;                                            // 堆指针指向新的空间
        HBT.MAXSIZE = HBT.MAXSIZE * 2;                                  // 修改堆空间大小
    }

    /* 新元素加入堆尾 */
    HBT.heap[HBT.currentLength] = item;
    ++HBT.currentLength;

    /* 自下而上的调整堆 */
    ElementType temp = item;                                            // 暂存新元素
    int down = HBT.currentLength - 1;                                   // down指示待调整位置
    while(down > 0) {                                                   // 从插入位置开始逐层向上调整
        int up = (down - 1) / 2;                                        // 找到待调整的元素的父亲节点
        if(temp >= HBT.heap[up])                                        // 若该层已经是小顶堆，则结束调整过程
            break;              
        HBT.heap[down] = HBT.heap[up];                                  // 对上一层调整
        down = up;              
    }               
    HBT.heap[down] = temp;                                              // 把插入元素放入最终位置
}

/*
 * 删除堆顶元素
 */
ElementType removeHeap(HeapSequence &HBT)
{
    /* 堆空 */
    if(HBT.currentLength == 0) {
        cout << "The heap is empty!
";
        exit(-1);
    }

    /* 自顶向下调整堆 */
    ElementType temp = HBT.heap[0];
    --HBT.currentLength;
    // 1、堆只有一个元素
    if(HBT.currentLenght == 0)     
        return temp;
    // 2、堆有多个元素
    ElementType tailValue = HBT.heap[HBT.currentLength];
    int up = 0;                                                                  // up指向待调整元素，开始指向根结点
    int down = 2 * up + 1;                                                              // down指向up结点的左孩子
    // 逐层向下调整，直到待调整结点为叶子结点(“筛选”)
    while(down <= HBT.currentLength - 1) {
        if((down < HBT.currentLength - 1) && (HBT.heap[down] > HBT.heap[down + 1]))     // 使down指向左右孩子中值小者
            ++down;
        if(tailValue <= HBT.heap[down])                                          // 若到某层已经是小顶堆，则终止调整过程
            break;
        HBT.heap[up] = HBT.heap[down];                                                  // 孩子结点值移交值父亲结点

        // 对下一层开始调整
        up = down;
        down = 2 * up + 1;
    }
    HBT.heap[up] = tailValue;                                                           // 待调整元素放入最终位置

    return temp;                                                                        // 返回堆顶删除的元素
}

OK哒!O(∩_∩)O哈哈~