算法与数据结构系列之[最大堆-中]

上篇介绍了最大堆的理论和重点操作的实现，这篇贴出最大堆的C语言代码实现：

MaxHeap.c

#include <stdlib.h>
#include <stdio.h>

#define INCREMENT 10 //数组扩容时的增量

typedef struct MaxHeap{
    int *data;   //定义一个动态数组
    int size;   //元素个数
    int capacity;  //数组最大容量
}Heap,*MaxHeap;

//初始化最大堆
MaxHeap InitMaxHeap(int initSize){
    MaxHeap heap = (MaxHeap)malloc(sizeof(Heap));
    heap->data = (int*) malloc(initSize * sizeof(int));
    heap->size = 0;
    heap->capacity = initSize;
    return heap;
}

//最大堆的元素个数
int GetMaxHeapSize(MaxHeap maxHeap){
    return maxHeap->size;
}

//判断最大堆是否为空
int IsMaxHeapEmpty(MaxHeap maxHeap){
    if(maxHeap->size == 0)
        return 1;
    return 0;
}

//返回给定索引表示的父节点在数组中的索引
int Parent(int index){
    if(index == 0){
        printf("根节点没有父节点");
        exit(0);
    }
    return (index -1)/2;
}

//返回给定索引表示的左孩子节点的索引
int LeftChild(int index){
    return index * 2 + 1;
}

//返回给定索引表示的右孩子的索引
int RightChild(int index){
    return index * 2 + 1;
}

/**
* 向堆中添加元素
* 在堆的末尾添加完元素后可能就不满足子节点都不大于父节点这一性质，需要将新添加的元素和它的父节点进行比较，如果大于其父节点，就
* 将该节点和父节点交换位置,该操作叫做堆的上浮操作
* @param maxHeap
* @param e
*/
void Add(MaxHeap maxHeap,int e){
    //数组达到给定的最大容量时扩容
    if(maxHeap->size == maxHeap->capacity){
        maxHeap->data = (int *) realloc(maxHeap->data,(maxHeap->capacity + INCREMENT) * sizeof(int));
        if(!maxHeap->data){
            printf("存储空间分配失败");
            exit(-1);
        }
        maxHeap->capacity += INCREMENT;
    }
    //第一步：在数组末尾添加元素
    maxHeap->data[maxHeap->size] = e;
    maxHeap->size++;
    //第二步：上浮操作
    int insertIndex = maxHeap->size - 1;  //新插入节点的索引值
    while (insertIndex > 0 && maxHeap->data[insertIndex] > maxHeap->data[Parent(insertIndex)]){
        int temp = maxHeap->data[insertIndex];
        maxHeap->data[insertIndex] = maxHeap->data[Parent(insertIndex)];
        maxHeap->data[Parent(insertIndex)] = temp;
        insertIndex = Parent(insertIndex);
    }
}

/**
* 从堆中删除元素
* 最大堆每次删除的都是堆中的最大元素
* 删除时先将数组下标为0的元素和数组中最后一个元素交换位置，再把数组最后一个元素删除掉。
* 接着将数组下标为0的元素和该元素的左右子节点比较，如果小于其子节点，则交换位置，直到满足最大堆的性质
* 该操作叫做堆的下沉操作
* @param maxHeap
*/
int RemoveMax(MaxHeap maxHeap){
    int res = maxHeap->data[0];
    if(IsMaxHeapEmpty(maxHeap)){
        printf("该堆为空，无法删除元素");
        exit(0);
    }
    //第一步：交换位置
    int tem = maxHeap->data[0];
    maxHeap->data[0]= maxHeap->data[maxHeap->size - 1];
    maxHeap->data[maxHeap->size - 1] = tem;
    //第二步：删除堆中最大元素
    maxHeap->size--;
    //第三步：堆的下沉操作
    int k = 0;
    while (LeftChild(k) < maxHeap->size){
        int j = LeftChild(k);
        if(j + 1 < maxHeap->size && maxHeap->data[j+1] > maxHeap->data[j])
            j = RightChild(k);
        if(maxHeap->data[k] >= maxHeap->data[j])
            break;
        int temp = maxHeap->data[k];
        maxHeap->data[k] = maxHeap->data[j];
        maxHeap->data[j] = temp;
        k = j;
    }
    return res;
}

MaxHeap.h

/初始化最大堆
MaxHeap InitMaxHeap(int initSize);
//最大堆的元素个数
int GetMaxHeapSize(MaxHeap maxHeap);
//判断最大堆是否为空
int IsMaxHeapEmpty(MaxHeap maxHeap);
//向堆中添加元素
void Add(MaxHeap maxHeap,int e);
//从堆中删除元素
int RemoveMax(MaxHeap maxHeap);

main.c

int num[10] = {62,42,30,28,15,22,13,19,17,14};
//初始化堆
MaxHeap maxHeap = InitMaxHeap(10);
//向堆中添加元素
for (int i = 0; i <10 ; ++i) {
    Add(maxHeap,num[i]);
}
//遍历堆中元素
for (int i = 0; i < maxHeap->size; ++i) {
    printf("%d ",maxHeap->data[i]);
}
//获取堆的大小
printf("\n");
printf("%d",GetMaxHeapSize(maxHeap));
printf("\n");
//添加元素
Add(maxHeap,55);
//再次遍历堆中元素
for (int i = 0; i < maxHeap->size; ++i) {
    printf("%d ",maxHeap->data[i]);
}
printf("\n");
//获取堆的大小
printf("%d",GetMaxHeapSize(maxHeap));
printf("\n");


//删除堆中一个元素
RemoveMax(maxHeap);
//再次遍历堆中元素
for (int i = 0; i < maxHeap->size; ++i) {
    printf("%d ",maxHeap->data[i]);
}
printf("\n");
//获取堆的大小
printf("%d",GetMaxHeapSize(maxHeap));
printf("\n");

运行结果：

62 42 30 28 15 22 13 19 17 14
10
62 55 30 28 42 22 13 19 17 14 15
11
55 28 30 19 42 22 13 15 17 14
10