堆和优先队列的应用

什么是堆：

堆的定义：n个元素的序列k={k_0,k1,……,k_n-1},当且仅满足条件
(1)k_i >= k2i+1 和 k_i >= k_2i+2      (2)k_i <= k_2i+1 和 k_i <= k_2i+2

(1)称为大根堆 (2)称为小根堆

可以把堆看成完全二叉树。

 

什么是优先队列：

优先队列是一种常见的抽象数据类型，它与"队列"不同，不遵循"先进先出"原则，而遵循"最小元素先出"原则。

优先队列的基本操作有三个：
(1) 向优先队列里插入一个元素
(2) 在优先队列找出最小元素
(3) 删除优先队列中最小元素

可以用堆来实现有限队列 

 

优先队列的实现：

#include "stdio.h"
#include "stdlib.h"

typedef int DATATYPE;

/********************优先队列存储结构********************************/
struct priorityQueue 
{
    int MAXNUM; //存储结构长度
    int n; //实际元素个数
    DATATYPE * element;
};
typedef struct priorityQueue *PQ;

/********************创建优先队列***********************************/
PQ createPQ(int maxnum)
{
    PQ pq = NULL;
    pq = (PQ) malloc(sizeof(struct priorityQueue));
    if(NULL != pq)
    {
        pq->element = malloc(sizeof(DATATYPE) * maxnum);
        if(pq->element != NULL)
        {
            pq->MAXNUM = maxnum;
            pq->n = 0;
        }
    }
    return pq;
}

/****************************判断优先队列是否为空****************************/
int isEmpty_heap(PQ pq)
{
    return pq->n == 0;
}

/**************************往优先队列中插入元素*******************************/
void add_heap(PQ pq, DATATYPE x)
{
    int i = -1; //标志元素最后要插入位置的下标
    if(pq->n >= pq->MAXNUM) //如果队列已满，无法插入
    {
        printf("PriorityQueue is full");
        return;
    }
    //寻找插入的位置,pq->n是未有元素的空位
    for(i = pq->n; i > 0 && x < pq->element[(i-1)/2]; i = (i - 1)/2)
    {
        pq->element[i] = pq->element[(i-1)/2];
    }
    //插入元素
    pq->element[i] = x;
    pq->n++;
}

/*************************在三个元素中，找出最小元素的下标********************/
int findMinIndex(PQ pq,int index1, int index2, int index3)
{
    int min = 0;
    min = (pq->element[index1] < pq->element[index2])?index1:index2;
    min = (pq->element[min] < pq->element[index3])?min:index3;
    return min;
}

/*************************删除优先队列最小元素************************************/
void removeMin_heap(PQ pq)
{
    int endIndex,leftchild,rightchild,index,minIndex;
    if(isEmpty_heap(pq)) //如果为空队列，返回
        return;
    endIndex = --pq->n; //找到队列尾元素下标,并将首元素删除

    index = 0; //空位的下标，开始时在根节点处
    for(;index < endIndex;)
    {
        leftchild = index*2 + 1;
        rightchild = index*2 + 2;
        if(leftchild > endIndex || rightchild > endIndex)
        {
            pq->element[index] = pq->element[endIndex];
            break;
        }            
                
        minIndex = findMinIndex(pq,endIndex,leftchild,rightchild);
        pq->element[index] = pq->element[minIndex];
        if(minIndex == endIndex)
            break;
        else if(minIndex == leftchild)
            index = leftchild;
        else if(minIndex == rightchild)
            index = rightchild;
    }
}



/***********************显示优先队列中元素的排列****************************/
void show(PQ pq)
{
    int i = 0;
    
    for(i = 0; i < pq->n; i++)
    {
        printf("%d, ",pq->element[i]);
    }

}

int main()
{
    PQ pq = createPQ(6);
    add_heap(pq, 3);
    add_heap(pq, 2);
    add_heap(pq, 8);
    add_heap(pq, 4);
    add_heap(pq, 6);
    add_heap(pq, 10);
    
    show(pq);
    printf("\n");
    
    removeMin_heap(pq);
    show(pq);
    return 0;
}

删除优先队列的原理为：在最小节点被删除后，根节点形成一个空位，这时考虑能否把处在队中最后位置的节点填入这里。由于这样做可能破坏堆序性，所以选择这个元素与根的两个子节点中最小的节点填入，选择的结果可能使得原来的空位向叶节点方向传递。如此反复交换，最终到堆中最后节点小于等于空位的两个子节点时，将最后节点填入这个空位。

 

利用堆，可以进行排序：

/********************对元素进行排序*********************************/
void sort(DATATYPE * data,int size)
{
    int i; 
    PQ pq = createPQ(size);

    for(i = 0; i < size; i++)
    {
        add_heap(pq,data[i]);
    }

    for(i = 0; i < size; i++)
        printf("%d, ",removeMin_heap(pq));
}

测试：

int main()
{    
    int i = 0;
    int a[100];
    for(i = 99; i >= 0; i--)
        a[i] = i * 2 + 1;


    sort(a,100);
    return 0;
}

 输出结果：

 

数组长度的限制：

栈里能声明的最大是１Ｍ 
也就是char　a［n］的大小不能大于１Ｍ 
堆里的可以很大 
也就是char　＊　a；　a＝new   char   [n]的话a的大小可以达２Ｇ