数据结构—堆

    堆是二叉树中的一种，是一种常见的数据结构，具有以下性质：

• 任意节点小于（最小堆）或大于（最大堆）它的所有后裔，最小元或最大元在堆的根上（堆序性）。
• 堆总是一棵完全二叉树

      最大堆如图一，最小堆如图二。

    

    最小堆的实现如下：

    MinHeap.h

#include "stdafx.h"
#include <iostream>
using namespace std;
template <typename Type>
class MinHeap{
public:
    MinHeap(int size):maxSize(size>defaultSize?size:defaultSize),
        currentSize(0),heap(new Type[maxSize]){}
    MinHeap(Type array[],int n);   // 用数组初始化堆
    ~MinHeap(){
        delete []heap;
    }
public:
    bool insertItem(const Type item);   // 插入元素
    bool deleteItem(const Type item);   // 删除元素
    bool isEmpty()const{           //判空
        return currentSize==0;
    }
    bool isFull()const{            // 判满
        return currentSize == maxSize;
    }
    void print();   //打印堆
private:
    void adjustHeap(const int start , const int end);  // 调整堆
private:
    static const int defaultSize = 100;
    const int maxSize;
    Type *heap;
    int currentSize;
};

// 用数组初始化堆
template<typename Type>
MinHeap<Type>::MinHeap(Type array[],int n)
    :maxSize(n>defaultSize?n:defaultSize),currentSize(n){
    heap = new Type[maxSize];
    for(int i = 0 ; i<n ;i++){
        heap[i] = array[i];
    }
    int pos = (n-2)/2;
    while(pos>=0){
        adjustHeap(pos,n-1);
        pos--;
    }
}
//  调整堆
template <typename Type>
void MinHeap<Type>::adjustHeap(const int start , const int end){
    int i = start;
    int j = 2*i+1;
    Type item = heap[i];
    while (j<=end){
        if(j<end&&heap[j]>heap[j+1])j++;
        if(item > heap[j]){
            heap[i] = heap[j];
            i=j;
            j=i*2+1;
        }
        else break;
    }
    heap[i] = item;
}
// 插入元素
template <typename Type>
bool MinHeap<Type>::insertItem(const Type item){
    if(isFull()){
        cout <<"this heap is full ,can't insert the element" <<endl;
        return 0;
    }
    heap[currentSize] = item;
    int j = currentSize, i = (j-1)/2; 
    Type temp = heap[j];
    while(j > 0){   
        if(heap[i] <= temp){
            break;
        }
        else{
            heap[j] = heap[i];
            j = i;
            i = (j-1)/2;
        }
    }
    heap[j] = temp;
    currentSize++;
    return 1;
}
// 删除元素
template <typename Type>
bool MinHeap<Type>::deleteItem(const Type item){
    if(isEmpty()){
        cout << "this heap is empty "<< endl;
        return 0;
    }
    int pos = 0;
    for(; pos<currentSize; pos++){
        if(heap[pos]==item){
            if(pos==currentSize-1)currentSize--;
            else{
                heap[pos] = heap[currentSize-1];
                currentSize--;
                adjustHeap(pos,currentSize);
                return 1;
            }
        }
        
    }
    return 0;
}
// 输出堆
template <typename Type>
void MinHeap<Type>::print(){
    cout << "heap";
    for(int i = 0 ; i< currentSize ; i++){
        cout << "->" << heap[i];
    }
    cout << endl;
}

  测试：

// Heap.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "HeapNode.h"

int _tmain(int argc, _TCHAR* argv[])
{
    
    int array[]={8,5,2,3,1,20,6,7,54,9,10};
    MinHeap<int> heap(array,11);
    heap.print();
    heap.insertItem(63);
    heap.print();
    heap.insertItem(0);
    heap.print();
    heap.deleteItem(5);
    heap.print();
    return 0;
}