二叉堆的实现

binary_heap.h

#ifndef __BINARY_HEAP__
#define __BINARY_HEAP__
typedef int ElementType;
struct binary_heap_s {
    unsigned int capacity; /*能存储的元素总数*/
    unsigned int size;   /*当前元素的个数*/
    ElementType *elements; /*元素列表*/
};
typedef struct binary_heap_s* binary_heap_t;
binary_heap_t init_binary_heap(unsigned int capacity);
void insert(ElementType element,binary_heap_t binary_heap);
ElementType deletemin(binary_heap_t binary_heap);
#endif

binary_heap.c

</pre><pre code_snippet_id="1699191" snippet_file_name="blog_20160527_5_5312836" name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "binary_heap.h"

binary_heap_t init_binary_heap(unsigned int capacity)
{
    binary_heap_t binary_heap;
   
    binary_heap = (binary_heap_t)malloc(sizeof(struct binary_heap_s));
    if(NULL == binary_heap) {
        printf("error: failed to malloc for binary heap\n");
        return NULL;
    }
    binary_heap->capacity = capacity;
    binary_heap->size = 0;
    binary_heap->elements = (ElementType*)malloc(sizeof(ElementType)*(capacity+1));
    if(binary_heap->elements == NULL) {
        printf("error: failed to malloc for binary heap elements\n");
        free(binary_heap);
        binary_heap = NULL;
        return NULL;
    }
    binary_heap->elements[0] = 0;  /*数组第一个元素不用*/
    return binary_heap;
}

void insert(ElementType element,binary_heap_t binary_heap)
{
    unsigned int index;
    unsigned int parent_index;
    /*在最后一个节点后面添加一个节点，组成新的完全二叉树*/
    if(binary_heap->size >= (binary_heap->capacity-1)) {
        printf("warning: the binary heap is full,can't insert element %d\n",element);
        return;
    }
    index = ++(binary_heap->size); /*新的节点索引*/
    /*while(index > 0) { //index 为unsigned int, 所以不会为负数,但是有可能为0，而0是哨兵节点，不需要处理
        parent_index = index/2;
        if((parent_index != 0) && binary_heap->elements[parent_index] > element) {
            binary_heap->elements[index] = binary_heap->elements[parent_index];
            index = parent_index;
        }else {
            break;
        }
    }*/
    /*由index/2保证运行到elements[0]的时候不进行了,因为elements[0]是哨兵节点，不需要处理，默认应该是最小值*/
    while((index/2 != 0) && (binary_heap->elements[index/2] > element)) {
            binary_heap->elements[index] = binary_heap->elements[index/2];
            index = index/2;
    }
 
    /*for(index=++binary_heap->size;(index/2 != 0) &&(binary_heap->elements[index/2]>element);index/=2) {
        binary_heap->elements[index] = binary_heap->elements[index/2];
    }*/
    binary_heap->elements[index] = element;
    return;
}
ElementType deletemin(binary_heap_t binary_heap)
{
    ElementType element; /*返回值*/
    ElementType last_elemnt; /*当前最后一个值*/
    unsigned int index;
    unsigned int new_index;

    /*二叉堆为空*/
    if(binary_heap->size == 0) {
        printf("error: the binary heap is empty\n");
        return (ElementType)0;
    }
    element = binary_heap->elements[1]; /*返回第一个元素，注意这里不是elements[0]*/
    last_elemnt = binary_heap->elements[binary_heap->size];
    binary_heap->size--;/*二叉堆元素个数减1*/
    
    for(index = 1; index <= binary_heap->size/2;index = new_index) 
    {
        if((2*index+1 > binary_heap->size) || (binary_heap->elements[2*index] < binary_heap->elements[2*index+1])) {
            new_index = 2*index;
        }else {
            new_index = 2*index+1;
        }
        if(binary_heap->elements[new_index] < last_elemnt) {
            binary_heap->elements[index] = binary_heap->elements[new_index]; 
        }else {
            break;
        }
    }
    binary_heap->elements[index] = last_elemnt;

    return element;
}
void printf_binary_heap(binary_heap_t binary_heap)
{
    unsigned int index;
    for (index = 0; index <= binary_heap->size;index++) {
        printf("binary_heap->elements[%d]=%d\n",index,binary_heap->elements[index]);
    }
    return;
}
#define MAX_HEAP_SIZE 11
int main(int argc, char *argv[])
{
    binary_heap_t binary_heap;
    binary_heap = init_binary_heap(MAX_HEAP_SIZE);
    if(binary_heap == NULL) {
        printf("error: init_binary_heap error\n");
        return -1;
    }
    insert(56,binary_heap);
    insert(34,binary_heap);
    insert(99,binary_heap);
    insert(43,binary_heap);
    insert(1,binary_heap);
    insert(60,binary_heap);
    insert(70,binary_heap);
    insert(30,binary_heap);
    insert(20,binary_heap);
    insert(25,binary_heap);
    printf_binary_heap(binary_heap);
    deletemin(binary_heap);
    printf("--------------------\n");
    printf_binary_heap(binary_heap);
    deletemin(binary_heap);
    printf("--------------------\n");
    printf_binary_heap(binary_heap);
    deletemin(binary_heap);
    printf("--------------------\n");
    printf_binary_heap(binary_heap);

    return 0;
}

[root@localhost c_language]# gcc -g binary_heap.c -o binary_heap
[root@localhost c_language]# ./binary_heap 
binary_heap->elements[0]=0
binary_heap->elements[1]=1
binary_heap->elements[2]=20
binary_heap->elements[3]=60
binary_heap->elements[4]=30
binary_heap->elements[5]=25
binary_heap->elements[6]=99
binary_heap->elements[7]=70
binary_heap->elements[8]=56
binary_heap->elements[9]=34
binary_heap->elements[10]=43
--------------------
binary_heap->elements[0]=0
binary_heap->elements[1]=20
binary_heap->elements[2]=25
binary_heap->elements[3]=60
binary_heap->elements[4]=30
binary_heap->elements[5]=43
binary_heap->elements[6]=99
binary_heap->elements[7]=70
binary_heap->elements[8]=56
binary_heap->elements[9]=34
--------------------
binary_heap->elements[0]=0
binary_heap->elements[1]=25
binary_heap->elements[2]=30
binary_heap->elements[3]=60
binary_heap->elements[4]=34
binary_heap->elements[5]=43
binary_heap->elements[6]=99
binary_heap->elements[7]=70
binary_heap->elements[8]=56
--------------------
binary_heap->elements[0]=0
binary_heap->elements[1]=30
binary_heap->elements[2]=34
binary_heap->elements[3]=60
binary_heap->elements[4]=56
binary_heap->elements[5]=43
binary_heap->elements[6]=99
binary_heap->elements[7]=70