堆的学习笔记和堆的相关操作

 本博客的代码的思想和图片参考：好大学慕课浙江大学陈越老师、何钦铭老师的《数据结构》

堆(Heap)

1:引子

1.1 需求

在一个操作系统中，CPU如何处理进程。如果按照时间先后排序，那么

对优先权较高的线程来说，就会出现问题。我们必须建立一种组织方式

假设我们每次从"队列"里面取出的元素，是按照优先权大小，而不是如"队列"

的时间顺序，如何进行组织？

1.2比较我们之前使用过的几种数据结构

1.2.1 数组

插入：总是在最后，时间复杂度为O(1)

删除：

查找最大或者最小元素，时间复杂度为O(n)

删除找到的最大最小元素，时间复杂度为O(n)

1.2.2 链表

插入：总是插入在链表的头部 时间复杂度O(1)

删除：

查找到最大或者最小元素，时间复杂度O(n)

删除元素，时间复杂度O(1)

1.2.3 有序数组

插入：

找到合适位置，时间复杂度O(n)或者O(log2 N)

移动元素位置：O(n)

删除：删去最后一个元素

1.2.4 有序链表

插入：找到合适的位置，时间复杂度O(n)

删除：删除首元素或者尾元素，时间复杂度O(1)

上面的数据结构至少都需要O(n)的时间复杂度，不是我们所需要的

我们使用二叉搜索树看看怎么样。

1.2.5 二叉搜索树

插入：找到元素的位置 时间复制度O(log2 N)

删除：最大最小元素在二叉搜索树的最左边或者最右边，时间复杂度O(log2 N)

这么一看，感觉还是可以的，但是我们发现，我们每次删除的都是最大(最小)元素

那么如果一直这么操作，这棵树会歪掉。我们得重新定义树的结构要求。

2 引入堆的概念

2.1 堆的特性

结构性：使用数组来表示完全二叉树的特性

有序性：任意节点的关键字是其子树所有节点的最大值(最小值)

最大堆(MaxHeap)，也称“大顶堆”：最大值

最小堆(MinHeap),也称“小顶堆”：最小值

2.2 堆的演示图

 

堆的示意图：

 

不是堆的示意图：

 

2.3 堆的要求是

从根节点到任意节点的路径上节点序列都有序

2.4 堆的数据结构的定义

typedef int elementType;

 

typedef struct heapStruct *maxHeap;

struct heapStruct{

    elementType *elementArray;/*定义存储元素的数组*/

    int size;/*堆当前元素的个数*/

    int capacity;/*堆的最大容量*/

 

};

2.5 堆的操作集合

类型名称： 最大堆（ MaxHeap）
数据对象集： 完全二叉树，每个结点的元素值不小于其子结点的元素值
操作集：最大堆H Î MaxHeap，元素item Î ElementType，主要操作有：

2.5.1 创建一个空的最大堆

MaxHeap Create( int MaxSize );

算法思想：

a.分配一个内存空间给 heapStruct

b.在分配 (MaxSize+1) * elementType 的数组空间给 elementArray

c.设置 size=0

d.设置capacity=MaxSize

e.我们设置了MaxSize+1个元素，我们让元素的角标从1开始，那么在第0号角标，我们设置一个MaxValue作为哨兵。MaxValue要求大于所有的堆元素

2.5.2判断最大堆H是否已满

Boolean IsFull( MaxHeap H );

算法思想：如果size==capacity,则堆满了

2.5.3 将元素item插入最大堆H

Insert( MaxHeap H, ElementType item );

算法思想：

不论什么元素，先把元素插入到数组的末尾，在和根元素进行比较，比根元素大就进行交换，否则不进行调整。调整以后，在比较，是否还是比根元素大，若还是大，在进行条，一直到比MaxValue小为止。下面使用图解来说明

 

2.5.4 判断最大堆H是否为空

Boolean IsEmpty( MaxHeap H )

算法思想：如果size==0,表示堆为空

2.5.5 删除堆中最大元素，并返回

ElementType DeleteMax( MaxHeap H )

算法思想：算法思想：先使用数组最末尾的元素替换第一个元素(根元素),然后判断当前根元素的左右孩子是否比根元素大，如果是，进行调整。一直这样进行递归，直到当前根元素比左右孩子都大，这样，就得到了堆。下面看演示图：

 

2.5.6 建立一个堆

需求：给你N个数据，如何在快速的建立一个堆

方法1：我们可以按照堆插入算法，把这些元素，一个个的插入堆中。一个元素插入堆的时间复杂度为O(log2 N),N个元素插入堆中的时间复杂度为O(N * log2 N)

方法2：我们依次把这些元素放入数组中(构建完全二叉树)，然后从倒数第一个有孩子的节点的元素开始，按照删除元素的思路，对该节点和其孩子进行调整，使该节点和它对于的孩子变成一个堆。然后在往前推一个元素，在进行如此操作，就完成了快速建立一个堆。

时间复杂度的计算：

结点数 最多交换次数
n/4 1
n/8 2
n/16 3
……
n/2^k=1 log2n-1 (k-1)

所有时间复杂度为N，比第一种方法要好得多。

下面是具体的演示过程：

 

#include<stdio.h>
#include<stdlib.h>
#define MAXDATA 65536

typedef int elementType;

typedef struct heapStruct *maxHeap;
struct heapStruct{
    elementType *elementArray;/*定义存储元素的数组*/
    int size;/*堆当前元素的个数*/
    int capacity;/*堆的最大容量*/

};

/*
    create a heap appointed maxsize
    @param maxSize The max size of the max heap
    @return a initialized empty heap.
*/
maxHeap createEmptyHeap(int maxSize){
    maxHeap heap = (maxHeap)malloc(sizeof(struct heapStruct));
    /*把数组元素空间分配出来*/
    heap->elementArray = (elementType *)malloc(sizeof((maxSize+1)*sizeof(elementType)));
    heap->size=0;
    heap->capacity = maxSize;
    /*define the max value as 哨兵, we will make update easy*/
    heap->elementArray[0]=MAXDATA;
    return heap;
}

/*
Judge the heap whether is full.
@param heap The heap need to judge
@return 1 will be returned if the heap is full, otherwise will return 0
*/
int isHeapFull(maxHeap heap){
    return (heap->size==heap->capacity);
}

/*
Judge the heap whether is emppty.
@param heap The heap need to judge
@return 1 will be returned if the heap is empty, otherwise will return 0
*/
int isHeapEmpty(maxHeap heap){
    return (heap->size==0);
}

/*insert element to heap,we will update it if necessary
@param heap The heap exsit
@param element The element need to insert
*/
void insertHeap(maxHeap heap,elementType element){
    int i;
    if(isHeapFull(heap)){
        printf("the heap is full
");
        return;
    }
    i = ++heap->size;
    heap->elementArray[i]=element;
    for( ; heap->elementArray[i/2]<element;i=i/2){
        heap->elementArray[i]=heap->elementArray[i/2];
    }
    heap->elementArray[i]= element;
}

elementType deleteMax(maxHeap heap){
    int parent,child;
    elementType maxElement,temp;
    if(isHeapEmpty(heap)){
        printf("the heap has bean empty
");
        return;
    }
    /*取出最大元素*/
    maxElement = heap->elementArray[1];
    temp=heap->elementArray[heap->size--];
    for(parent=1;parent*2<heap->size;parent=child){
        child = parent*2;
        /*
        child!=heap->size:indicate the heap has a right child
        heap->elementArray[child]<heap->elementArray[child+1]:the value of right greater than the value of left
        the code of IF is to find the index of the bigger value of left child and right child
        */
        if((child!=heap->size)&& heap->elementArray[child]<heap->elementArray[child+1]){
            child++;/*get the right child index*/
        }
        if(temp>=heap->elementArray[child]){
            break;/*temp find a suitable station*/
        }else{
            /*move bigger element to parent station*/
            heap->elementArray[parent]=heap->elementArray[child];
        }
    }

    heap->elementArray[parent]=temp;
    return maxElement;
}


/*
print the heap
@param heap The heap nend to print to the controal
*/
void toString(maxHeap heap){
    maxHeap p = heap;
    printf("toString:");
    int i=1;
    while(i<=p->size){
        printf("%d ",p->elementArray[i]);
        i++;
    }
    printf("
");
}


/*
    construct the max heap,the algorithem thought is same with delete method
    @param heap The binary tree who want to construct a max heap
    @param p The parent index of the tree
*/
void percDown(maxHeap heap,int p){
    elementType temp=heap->elementArray[p];
    int parent,child;
    for(parent=p;parent*2<=heap->size;parent=child){
        child = parent *2;
        if((child!=heap->size) && heap->elementArray[child]<heap->elementArray[child+1]){
            child++;
        }
        if(temp>=heap->elementArray[child]){
            break;
        }else{
            heap->elementArray[parent]=heap->elementArray[child];
        }
    }
    heap->elementArray[parent]=temp;
}

/*
make a binary tree to be a heap
@param heap The binary tree need to transfer into heap
*/
void buildMaxHeap(maxHeap heap){
    int i;
    /*
    maxHeap heap = createEmptyHeap(10);
    maxHeap heap = createEmptyHeap(10);
    printf("lala,%d
",length);
    for(i=1;i<=length;i++){
        heap->elementArray[++heap->size]=a[i-1];
    }
    */
    for(i=heap->size/2;i>0;i--){
        percDown(heap,i);
    }

}

/*
void testBuildHeap(){
    int i;
    maxHeap heap2 = createEmptyHeap(10);
    for(i=1;i<=10;i++){
        heap2->elementArray[++heap2->size]=i;
    }
    toString(heap2);
    buildMaxHeap(heap2);
    toString(heap2);
}
*/
int main(){

    int i,arr[10];
    maxHeap heap = createEmptyHeap(30);

    for(i=1;i<=10;i++){
        heap->elementArray[++heap->size]=i;
    }
    printf("build a bianray tree,not heap	");
    toString(heap);
    buildMaxHeap(heap);
    printf("constructor a binary into a heap	");
    toString(heap);
    for(;i<=20;i++){
        insertHeap(heap,i);
    }
    printf("test insert method	");
    toString(heap);
    printf("delete max element%d
",deleteMax(heap));
    toString(heap);
    printf("delete max element%d
",deleteMax(heap));
    toString(heap);
    printf("delete max element%d
",deleteMax(heap));
    toString(heap);
    printf("delete max element%d
",deleteMax(heap));
    toString(heap);
    //testBuildHeap();
    printf("just test");
    return 0;
}

下面是结果演示：