二叉堆 - 最小堆

二叉堆：一般我们拿来用的就是最大堆和最小堆。

最小堆：每个节点的值比它的左右子节点的值要大。

代码实现如下：参考Mark Allen Weiss《数据结构和算法分析》（第二版）

#include <cstdio>
#include <cstdlib>

#define MIN (1<<(sizeof(int)*8-1))

typedef int Item;
typedef struct HeapStruct* heap;

struct HeapStruct {
    int capacity;  // capacity的大小为堆的元素加1。 
    int size;      // size指向堆中最后一个元素，size=0时堆为空 
    Item* items;   // items的第一个元素存放sentinel，其余元素存放堆中内容。 
};
// 初始化堆的三个参数 
heap
InitHeap(int maxItems)
{
    heap h;
    
    h = (heap)malloc(sizeof(struct HeapStruct));
    if (h == NULL) {
        printf("out of space.\n");
        return NULL;
    }
    
    h->items =(Item*)malloc((maxItems+1)*sizeof(Item)); // 用h->items[0]来存放sentinel 
    if (h->items == NULL) {
        printf("out of space.\n");
        return NULL;
    }
    
    h->capacity = maxItems;
    h->size = 0;
    h->items[0] = MIN;
    
    return h;
}
  
int
IsFull(heap h)
{
    if (h->size == h->capacity) {
        return 1;
    } else {
        return 0;
    }
}

int
IsEmpty(heap h)
{
    if (h->size == 0) {
        return 1;
    } else {
        return 0;
    }
}
  
Item
FindMin(heap h)
{
    return h->items[1];
}
// 向最小堆插入元素。  
void
Insert(Item item, heap h)
{
    if (IsFull(h)) {
        printf("Insert failed. Because the heap is full.\n");
        return;
    }
    // percolate up，将item往上，一步一步放到合适的地方。
    int i; 
    for (i = ++h->size; h->items[i/2] > item; i /= 2) {
        h->items[i] = h->items[i/2];
    }
    h->items[i] = item;
}
// 在最小堆中删除元素。 返回最小值。 
Item
DeleteMin(heap h)
{
    if (IsEmpty(h)) {
        printf("Delete failed. Because the heap is empty.\n");
        return h->items[0];
    }
    
    Item minItem = h->items[1];
    Item lastItem = h->items[h->size--]; // 此函数目的就是把lastItem放到合适位置 
    // percolate down，将lastItem往下，一步一步往下寻找合适的地方。
    int i, child;
    for (i = 1; 2*i <= h->size; i = child) {
        child = 2 * i;
        // 将child放在左右子树中较小的那个位置上
        if (child != h->size && h->items[child] > h->items[child+1]) {
            child++;
        }
        
        if (lastItem > h->items[child]) {
            h->items[i] = h->items[child];
        } else {
            break;
        }
    }
    h->items[i] = lastItem;
    return minItem;
}
// 以插入的方式来建堆。复杂度为O(NlogN)，因为有N个元素，每次插入花费logN时间。      
void
BuildHeap(heap h, Item arr[], int len)
{
    for (int i = 0; i < len; i++) {
        Insert(arr[i], h);
    }
}
// 以下滤的方式来建堆（对已有的数组进行排序，使之符合最小堆的堆序heap order）。
// 参数i为数组对应的二叉堆的内部节点，下滤操作将之放到比左右子节点都小的位置上。 
void
PercDown(heap h, int i) 
{
    int child;
    int tmp;
    
    for (tmp = h->items[i]; 2*i <= h->size; i = child) {
        child = 2*i;
        if (child != h->size && h->items[child] > h->items[child+1]) {
            child++;
        }
        if (tmp > h->items[child]) {
            h->items[i] = h->items[child];
        } else {
            break;
        }
    }
    h->items[i] = tmp;
}

int 
main(int argc, char** argv)
{
    int arr[6] = {17, 11, 2, 23, 5, 7};
    
    heap h;
    h = InitHeap(6);
    //BuildHeap(h, arr, 6);
    // build heap
    for (int i = 0; i < 6; i++) {
        h->items[++h->size] = arr[i];
        
    }
    for (int i = 6/2; i > 0; i--) {
        PercDown(h, i);
    }
    
    for (int i = 1; i <= h->size; i++) {
        printf("%d\t", h->items[i]);
    }
    printf("\n");
    
    // test DeleteMin, out put a sorted array
    int sortedArr[6] = {0};
    for (int i = 0; i < 6; i++) {
        sortedArr[i] = DeleteMin(h);
    }
    for (int i = 0; i < 6; i++) {
        printf("%d\t", sortedArr[i]);
    }
    printf("\n");
    
    system("pause");
    
    return 0;
}