C语言实现优先队列(priority queue)

        堆排序是一个比较优秀的算法,堆这种数据结构在现实生活中有很多的应用,比如堆可以作为一个优先队列来使用,作为一个高效的优先队列,它与堆的结构一样,都有最大优先队列,最小优先队列.优先队列priority queue 是一种用来维护一组元素构成的集合S的数据结构,每一个元素都有一个相关的值,称为关键字(key)。

        最大优先队列包含以下操作:

        INSERT( S,x) :将元素x插入到S的集合中,等价于S=S\cup \left\{ x \right\}

        MAXIMUM (S):返回S中最大元素;

        EXTRACT-MAX( S): 返回并且删除S中最大元素;

        INCREASE-KEY(S, x,key) :将元素x的关键字增加到key,要求key\geq x

        同样的,最小优先队列操作也包括:INSERT(S, x) ,MINIMUM(S ) ,EXTRACT-MIN(S ) ,DECREASE(S, x,key) 。只不过是对最小值进行操作。

        在这里主要讨论最大优先队列,其应用很多,在共享计算机作业系统就是,类似于早期的unix主机,管理员root可以设置n个不同的用户,以及各个用户不同的操作权限,从主机那里接出多个终端,每个操作人员(程序员)在自己的工作终端 ,感觉像是自己拥有自己独立的作业主机一样,其实不是,通过一些任务调度来实现,其中就有任务等待执行相关队列,并且有各个任务有着自己优先级,以便确定调度执行具体任务,如果你学过操作系统相关知识,那么应该对系统调度有所了解。

        当一个作业被完成或者被中断后,调度器会调用EXTRACT-MAX (S) 来调用所有在队列中等待任务中优先级最高的任务执行,在新任务加入等待任务时会调用INSERT(S, x) 加入任务等待队列,当某个任务等待时间过长时可通过INCREASE-KEY(S, x,key) 提高其优先级,从而减少等待时间。

        下面是具体实现C程序源码:

#include <stdio.h>

#define NAGE_INFINIT -99999

#define parent(i) i/2

#define left(i) 2*i+1

#define right(i) 2*i+2

//get array of A first element

int heap_maximum(int A[]){ return A[0];}

/***********************************************

*

* function max_heapify();

*

* args

*  A[] inttype save elements of heap

*  i index of A

*  heap_size real length of A

*

* ********************************************/

void max_heapify(int A[],int i,int heap_size){

    int l,r,largest,temp;

    l=left(i);

    r=right(i);

    if((l<=heap_size)&&(A[l]>A[i]))

        largest=l;

    else

        largest=i;

    if((r<=heap_size)&&(A[r]>A[largest]))

        largest=r;

    if(largest!=i){

        temp=A[i];

        A[i]=A[largest];

        A[largest]=temp;

        max_heapify(A,largest,heap_size);

    }

}

/*********************************************

*

* function heap_extract_max()

*

* args

*  A[] inttype save elements of heap

*  heap_size inttype the real length of A

*

* return max the parent node value

*

* ******************************************/

int heap_extract_max(int A[],int heap_size){

    int max;

    if(heap_size<0)

        return -1;  //heap underflow

    max=A[0];  //parent node the max value of element

    A[0]=A[heap_size];

    heap_size--;

    /**************************************

    * dajust binary heap(or tree) to make

    * sure heap fo A true every times

    *

    * ************************************/

    max_heapify(A,0,heap_size);

    return max;

}

/***********************************************

*

* function heap_increase_key();

*

* args

*  A[] inttype save elemnts of heap

*  i index of A

*  key inserted element

*

* *********************************************/

void heap_increase_key(int A[],int i,int key){

    int temp;

    if(key<A[i]){

        printf("new key is smaller than current key\n");

        return;    //over programming

    }

    A[i]=key;

    //p=parent(i);

    while ((i>0)&&(A[parent(i)]<A[i])) {

        temp=A[i];

        A[i]=A[parent(i)];

        A[parent(i)]=temp;

        i=parent(i); //update index of A

        //p=parent(i);

    }

}

/***************************************************

*

* function max_heap_insert();

*

* args

*  A[] inttype save elements of A

*  key inserted element to A

*  heap_size real length of A

*

* **************************************************/

void max_heap_insert(int A[],int key,int heap_size){

    heap_size+=1;

    A[heap_size]=NAGE_INFINIT;

    heap_increase_key(A,heap_size,key);

}

int main()

{

    int heap_max,max,i,key;

    int A[11],Temp[11];

    int heap_size=0;

    char c;

    while (1) {

        scanf("%d",&A[heap_size]);

        c=getchar();

        if(c=='\n')

            break;

        heap_size++;

    }

    //copy A to Temp

    for(i=0;i<=heap_size;i++)

        Temp[i]=A[i];

    //get heap maximum element

    heap_max=heap_maximum(A);

    printf("heap of A maximum element: %d\n",heap_max);

    //copy Temp to A

    for(i=0;i<=heap_size;i++)

        A[i]=Temp[i];

    /*--extract maximum element--*/

    max=heap_extract_max(A,heap_size);

    printf("extract element: %d \n",max);

    printf("new heap of A after extract maximum node\n");

    for(i=0;i<heap_size;i++)

        printf("%d ",A[i]);

    printf("\n");  //next line

    //copy Temp to A

    for(i=0;i<=heap_size;i++)

        A[i]=Temp[i];

    /*--increase from A[i] to key--*/

    printf("input i key ");

    scanf("%d %d",&i,&key);

    heap_increase_key(A,i,key);

    for(i=0;i<=heap_size;i++)

        printf("%d ",A[i]);

    printf("\n");

    //copy Temp to A

    for(i=0;i<=heap_size;i++)

        A[i]=Temp[i];

    /*--insert queueu--*/

    key=0;  //init key;

    printf("input key: ");

    scanf("%d",&key);

    max_heap_insert(A,key,heap_size);

    for(i=0;i<=heap_size+1;i++)

        printf("%d ",A[i]);

    printf("\n");

    return 0;

}

/****************************************

*

* input 16 14 10 8 7 9 3 2 4 1

*      i: 8

*      key: 15

*

* output in function main()

* **************************************/

其运行结果如下图:


图1.运行结果截图

欢迎留言交流,也感谢指正,一起进步。

©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。
禁止转载,如需转载请通过简信或评论联系作者。

相关阅读更多精彩内容

  • 我们之前已经介绍过队列-C语言实现,它们是先入先出的,这很容易用平常的排队来理解。但是如果这个队列要支持有紧急情况...
    编程小世界阅读 5,536评论 0 0
  • 优先队列是一种极其特殊的队列,他与标准的队列使用线性结构进行计算不同,优先队列的底层是以散列的状态(非线性)表现的...
    放心笑阅读 1,864评论 0 1
  • 原文地址:Objective-C封装std::priority_queue<>实现优先队列最近项目中需要用到优先队...
    我是恬恬酱阅读 6,440评论 0 0
  • 堆是一个数组,可以看作是一个近似于完全二叉树,树每个接点对应数组中的每个元素,除了最底层外,该树完全是满的,且在数...
    夜行候子阅读 3,233评论 0 5
  • 堆是一棵满足一定性质的二叉树,具体的讲堆具有如下性质:父节点的键值总是不大于它的孩子节点的键值(小顶堆), 堆可以...
    9527Roy阅读 3,919评论 0 0

友情链接更多精彩内容