数据结构：堆Heap

一、定义

  堆（heap），也叫优先队列(priority queue)，取出元素的顺序是依照元素的优先权(关键字)大小，而不是元素进入队列的先后顺序，也就是说堆的排序是按照自定义的顺序(优先权)。
  比如说，打印机在打印不同文件时，并不是按照文件的先后顺序来打印的，而是由文件是否急需来决定这些文件的打印顺序，这样的模型就是堆模型。
  堆最主要的操作有插入(insert)和删除(deleteMax/deleteMin)两种操作，堆有多种实现方式，比如说数组或链表，也可以采用完全二叉树存储结构来实现，完全二叉树非常适合实现堆，所以提到堆，默认就是树结构，这也是完全二叉树的一个应用，所以这里只讲二叉树实现的C语言代码。如下图所示，堆可分为最大堆和最小堆，最大堆是指子结点的值小于父结点，最小堆是值子结点的值大于父结点，注意，兄弟结点之间没有优先权排序的关系。

  以最大堆为例，12在第一个位置，11在第二个位置，9在第三个位置……

---

二、C语言实现

  这里以最大堆的实现为例。

//头文件，文件名：MaxHeap.h
#ifndef MAXHEAP_H_INCLUDED
#define MAXHEAP_H_INCLUDED
struct HeapStruct{
    //存放堆元素的数组，该数组下标为0的位置不存放堆元素，仅存放哨兵元素
    int* heapArr;
    int size;//存放堆的当前元素的数目
    int capacity;//存放该堆的容量
};
typedef struct HeapStruct* MaxHeap;

MaxHeap createMaxHeap(int);
void insert(int, MaxHeap);
int find(int, MaxHeap);

#endif // MAXHEAP_H_INCLUDED

//堆的具体实现文件，文件名：MaxHeap.c
#include <stdio.h>
#include <stdlib.h>
#include "MaxHeap.h"

MaxHeap createMaxHeap(int maxSize){
    MaxHeap maxHeap = (MaxHeap)malloc(sizeof(struct HeapStruct));
    maxHeap->heapArr = (int*)malloc(sizeof(int)*(maxSize+1));
    maxHeap->size = 0;
    maxHeap->capacity = maxSize;
    maxHeap->heapArr[0] = 0;//heapArr数组不存放堆的元素，只存放堆中的最大元素

    return maxHeap;
}

/*
查找到元素则返回元素在堆中的位置，否则返回0
*/
int find(int element, MaxHeap maxHeap){
    if(!maxHeap){
        printf("该堆不存在\n");
        return 0;
    }
    int i = 1;
    for(;i<=maxHeap->size;i++){
        if(element == maxHeap->heapArr[i]){
            return i;
        }
    }

    return 0;
}

/*
    朝一个堆里插入元素，
    原理：先在尾部插入元素，然后将该元素与父结点比较，如果父结点小于该元素，则两个元素互换位置，
    这叫采用上滤(percolate up)的方式搜索。
*/
void insert(int element, MaxHeap maxHeap){
    if(!maxHeap){
        printf("该堆不存在！\n");
        return;
    }
    if(find(element, maxHeap)){
        printf("堆中已存在元素%d，不再插入!\n", element);
        return;
    }
    if(maxHeap->size == maxHeap->capacity){
        printf("该堆的容量已满，不能再插入元素了\n");
        return;
    }else{
        /*
        因为这里可能需要使用哨兵元素来判断是否结束循环，
        所以哨兵元素在插入操作时，必须为待插入元素与该堆最大元素的较大者
        判断哨兵元素是否更新，更新后可以作为判断条件，
        但是插入数据后一定要将哨兵元素的值恢复成该堆的最大元素
        */
        if(maxHeap->heapArr[0]<element){
            maxHeap->heapArr[0] = element;
        }
        int i = ++maxHeap->size;
        for(;maxHeap->heapArr[i/2]<element;i/=2){
            maxHeap->heapArr[i] = maxHeap->heapArr[i/2];
        }
        maxHeap->heapArr[i] = element;
        //最后复原哨兵元素
        maxHeap->heapArr[0] = maxHeap->heapArr[1];
    }
}

/*
    删除并返回最大堆里的最大的元素
    原理：最大堆的最大元素为根结点上的元素，也就是说，等价于给根结点位置重新找子树中最大的元素，合并左右两颗最大堆。
先删除最后一个结点n(值替换根结点的值)，从根开始找出当前结点下较大的子结点，
然后用这个子结点的值与结点n的值比较，
如果大于结点n的值，则这个子结点的值移动到父结点的位置，该子节点的位置作为下一个父结点，继续向下查找；
如果小于结点n的值，则停止向下搜索。
这叫采用下滤(percolate down)的方式搜索。
*/
int deleteMax(MaxHeap maxHeap){
    int parent, child;//父结点和子结点的位置
    if(maxHeap->size == 0){
        printf("该最大堆已经不含有结点\n");
        return 0;
    }

    //初始堆里的最大值
    int maxItem = maxHeap->heapArr[1];
    //将初始堆的最后一个元素赋值给根结点，并且删除最后一个结点
    maxHeap->heapArr[1] = maxHeap->heapArr[maxHeap->size--];
    int temp = maxHeap->heapArr[1];
    //开始循环比较父结点与子结点的大小
    //parent*2<=maxHeap->size判断是否有子结点
    for(parent=1; parent*2 <= maxHeap->size; parent=child){
        child = parent*2;//左子结点的位置
        if((child!=maxHeap->size)&&(maxHeap->heapArr[child]<maxHeap->heapArr[child+1])){
            //child!=maxHeap->size成立的话，表明该parent结点有右子结点
            //maxHeap->heapArr[child]<maxHeap->heapArr[child+1]判断左右子结点的大小
            //如果if条件成立，那么parent的右结点比左结点大，此时child指向右结点的位置
            child++;
        }

        if(maxHeap->heapArr[child] > temp){
            maxHeap->heapArr[parent] = maxHeap->heapArr[child];
        }else{
            break;
        }
    }

    maxHeap->heapArr[parent] = temp;

    //修改哨兵
    maxHeap->heapArr[0] = maxHeap->heapArr[1];
    return maxItem;
}

/*
    根据一个数组直接建立堆
    而不是一个元素一个元素的插入
    原理：先无序将这个元素放入到堆里，
    然后按照删除元素的原理(下滤)从第一个含非空子结点(位置：最后一个叶结点的位置/2取整)的元素开始调整
*/

void createMaxHeapByArray(int arr[], int length, MaxHeap maxHeap){
    //MaxHeap maxHeap = createMaxHeap(length);
    /*
        因为这里数组里的元素并未放到maxHeap->heapArr里面
        所以需要把这些元素放进去
        其实这里不需要另一个数组，这里为了方便理解由数组建堆的原理，
        所以另加了一个数组。
    */
    maxHeap->size = length;
    //将数组元素依次放入完全二叉树里
    for(int j=0; j<length; j++){
        maxHeap->heapArr[j+1] = arr[j];
    }

    //开始调整
    int i;
    for(i = maxHeap->size/2; i>0; i--){
        int parent, child, element;
        element = maxHeap->heapArr[i];
        for(parent = i; parent*2<=maxHeap->size; parent=child){
            child = parent*2;
            if((child!=maxHeap->size)&&(maxHeap->heapArr[child]<maxHeap->heapArr[child+1])){
                child++;
            }
            if(element >= maxHeap->heapArr[child]){
                break;
            }else{
                maxHeap->heapArr[parent] = maxHeap->heapArr[child];
            }
        }

        maxHeap->heapArr[parent] = element;
    }
    maxHeap->heapArr[0] = maxHeap->heapArr[1];

}

//测试文件，文件名：main.c
#include "MaxHeap.h"
#include <stdio.h>
#include <stdlib.h>

int main()
{
    MaxHeap maxHeap = createMaxHeap(4);

    insert(15, maxHeap);
    insert(7, maxHeap);
    insert(9, maxHeap);
    insert(20, maxHeap);

    //查找元素7
    int position = find(7,maxHeap);
    printf("7在第%d个位置\n",position);
    //查找不存在的元素21
    int pos = find(21,maxHeap);
    printf("21在第%d个位置\n",pos);
    printf("\n");

    for(int i=1;i<=maxHeap->size;i++){
        printf("第%d元素为：%d\n", i, maxHeap->heapArr[i]);
    }
    printf("哨兵为:%d\n", maxHeap->heapArr[0]);
    printf("\n");

    //重复插入9
    insert(9, maxHeap);
    printf("\n");

    //测试删除最大元素
    int maxItem = deleteMax(maxHeap);
    printf("删除的最大元素为：%d\n", maxItem);
    printf("删除之后的堆为：\n");
    for(int i=1;i<=maxHeap->size;i++){
        printf("第%d元素为-----%d\n", i, maxHeap->heapArr[i]);
    }
    printf("哨兵为-----%d\n", maxHeap->heapArr[0]);

    //测试直接生成最大堆
    printf("\n");
    printf("根据数组直接生成最大堆\n");
    int arr[5] = {1,2,3,4,5};
    MaxHeap newMaxHeap = createMaxHeap(5);
    createMaxHeapByArray(arr, 5, newMaxHeap);

    for(int m = 1; m<=newMaxHeap->size; m++){
        printf("第%d元素为：%d\n", m, newMaxHeap->heapArr[m]);
    }

    return 0;
}

//结果：
//7在第4个位置
//21在第0个位置

//第1元素为：20
//第2元素为：15
//第3元素为：9
//第4元素为：7
//哨兵为:20

//堆中已存在元素9，不再插入!

//删除的最大元素为：20
//删除之后的堆为：
//第1元素为-----15
//第2元素为-----7
//第3元素为-----9
//哨兵为-----15

//根据数组直接生成最大堆
//第1元素为：5
//第2元素为：4
//第3元素为：3
//第4元素为：1
//第5元素为：2