SeqPriorityQueue——顺序优先级队列

原创 2012年03月29日 23:48:44

PS:

1、不用考虑“假溢出”的情况。

2、出队列时间复杂度为O(n)。将出队列元素后的元素均往前移1个索引。

/*
** File name: SeqPriorityQueue.h
** Author: ZhouFeng
** Date: 2012/03/29
*/
#ifndef SEQ_PRIORITY_QUEUE_H
#define SEQ_PRIORITY_QUEUE_H

#define BOOL int
#define TRUE 1
#define FALSE 0
#define ERROR 0
#define SUCCESS 1
#define MAX_SIZE 100

typedef int EleType;

typedef struct QueueEle
{
    int nPriority;
    EleType data;
}QueueEle;

typedef struct SeqPriorityQueue
{
    QueueEle aSPQueue[MAX_SIZE];
    int nRear;
    int nCount;
}SeqPriorityQueue;

void InitSPQ(SeqPriorityQueue *SPQ);
int SPQAppend(SeqPriorityQueue *SPQ, QueueEle queueEle);
int SPQDelete(SeqPriorityQueue *SPQ, QueueEle *pQueueElement);
BOOL IsSPQEmpty(SeqPriorityQueue *SPQ);
int GetSPQ(SeqPriorityQueue *SPQ, QueueEle *pQueueElement);

#endif


 

/*
** File name: SeqPriorityQueue.h
** Author: ZhouFeng
** Date: 2012/03/29
*/
#include <stddef.h>
#include <stdlib.h>
#include "SeqPriorityQueue.h"

void InitSPQ(SeqPriorityQueue *SPQ)
{
    int i = 0;
    
    if(SPQ == NULL)
    {
	return;
    }

    for(i = 0; i < MAX_SIZE; ++i)
    {
	(SPQ->aSPQueue)[i].nPriority = 0;
	(SPQ->aSPQueue)[i].data = 0;
    }
    SPQ->nRear = 0;
    SPQ->nCount = 0;
}

int SPQAppend(SeqPriorityQueue *SPQ, QueueEle queueEle)
{
    if(SPQ == NULL || SPQ->nCount >= MAX_SIZE)
    {
	return ERROR;
    }

    (SPQ->aSPQueue)[SPQ->nRear] = queueEle;
    ++(SPQ->nRear);
    ++(SPQ->nCount);

    return SUCCESS;
}

int SPQDelete(SeqPriorityQueue *SPQ, QueueEle *pQueueElement)
{
    int index = 0;
    int nMaxPriority = 0;
    int nMaxIndex = 0;
    
    if(SPQ == NULL || SPQ->nCount <= 0 || pQueueElement == NULL)
    {
	return ERROR;
    }

    /* Get the Max priority index. */
    nMaxPriority = (SPQ->aSPQueue)[0].nPriority;
    for(index = 1; index < SPQ->nCount; ++index)
    {
	if(nMaxPriority > (SPQ->aSPQueue)[index].nPriority)
	{
	    nMaxPriority = (SPQ->aSPQueue)[index].nPriority;
	    nMaxIndex = index;
	}
	else
	{
	    continue;
	}
    }

    (*pQueueElement).nPriority = nMaxPriority;
    (*pQueueElement).data = (SPQ->aSPQueue)[nMaxIndex].data;

    for(index = nMaxIndex + 1; index < SPQ->nCount; ++index)
    {
	(SPQ->aSPQueue)[index - 1] = (SPQ->aSPQueue)[index];
    }

    --(SPQ->nCount);

    return SUCCESS;
}

BOOL IsSPQEmpty(SeqPriorityQueue *SPQ)
{
    if(SPQ == NULL)
    {
	return TRUE;
    }

    if(SPQ->nCount == 0)
    {
	return TRUE;
    }
    else
    {
	return FALSE;
    }
}

int GetSPQ(SeqPriorityQueue *SPQ, QueueEle *pQueueElement)
{
    int index = 0;
    int nMaxPriority = 0;
    int nMaxIndex = 0;
    
    if(SPQ == NULL || SPQ->nCount <= 0 || pQueueElement == NULL)
    {
	return ERROR;
    }

    /* Get the Max priority index. */
    nMaxPriority = (SPQ->aSPQueue)[0].nPriority;
    for(index = 1; index < SPQ->nCount; ++index)
    {
	if(nMaxPriority > (SPQ->aSPQueue)[index].nPriority)
	{
	    nMaxPriority = (SPQ->aSPQueue)[index].nPriority;
	    nMaxIndex = index;
	}
	else
	{
	    continue;
	}
    }

    (*pQueueElement).nPriority = nMaxPriority;
    (*pQueueElement).data = (SPQ->aSPQueue)[nMaxIndex].data;

    return SUCCESS;
}


测试程序:

#include <stdio.h>
#include "SeqPriorityQueue.h"

int main(int argc, char *argv[])
{
    SeqPriorityQueue SPQ;
    QueueEle qe;
    int i = 0;
    
    InitSPQ(&SPQ);
    printf("[Original]\nPriority   Data\n");
    printf("--------- -------\n");
    for(i = 0; i < MAX_SIZE / 2; ++i)
    {
	qe.nPriority = MAX_SIZE / 2 - i;
	qe.data = i;
	SPQAppend(&SPQ, qe);
	printf("%5d%10d\n", qe.nPriority, qe.data);
    }

    for(i = 50; i < MAX_SIZE; ++i)
    {
	qe.nPriority = MAX_SIZE - i;
	qe.data = i;
	SPQAppend(&SPQ, qe);
	printf("%5d%10d\n", qe.nPriority, qe.data);
    }
    printf("\n");

    printf("[Get Queue]\nPriority   Data\n");
    printf("--------- -------\n");
    while(!IsSPQEmpty(&SPQ))
    {
	SPQDelete(&SPQ, &qe);
	printf("%5d%10d\n", qe.nPriority, qe.data);
    }

    return 0;
}


GDB调试:clear清除断点、u跳出循环。

顺序优先级队列

初学数据结构,一个小程序 SeqPQueue.h typedef struct DataType { ElemType elem; //数据元素 int pri...

云计算设计模式(十六)——优先级队列模式

云计算设计模式(十六)——优先级队列模式 优先发送到服务,以便具有较高优先级的请求被接收和高于一个较低优先级的更快速地处理请求。这种模式是在应用程序是有用的,它提供不同的服务级别保证或者针对独立客户。...

堆的应用——优先级队列

接上文:堆排序Heap Sort——浅显易懂+Java实现         堆分最小堆最大堆,优先级队列也分最小优先级队列和最大优先级队列。先来介绍一下优先级队列:         优先级队列是用...
  • qj30212
  • qj30212
  • 2016年09月06日 22:12
  • 158

生产消费者4 - 实现一个基于优先级的传输队列【消费顺序是由优先级决定的而不是抵达时间】

实现一个基于优先级的传输队列Java 7 API 提供几种与并发应用相关的数据类型。从这里面,我们想来重点介绍以下2种数据类型: LinkedTransferQueue:这个数据类型支持那些有生产者和...

(hdu step 8.1.5)看病要排队(优先队列的基本使用——在看病排队时,优先级高的排在前面.求在这种情况下的出队序列)

题目:看病要排队Time Limit: 3000/1000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)Total Submis...

优先级队列——PriorityQueue

优先级队列提起优先级队列,首先想到了操作系统中的作业调度算法的相关应用,还有就是解决 Top n (一个集合中最大或最小的n的元素)之类的问题。 操作系统中的作业调度有短作业优先(SJF)、先来先服务...

LinkPriorityQueue——链式优先级队列

直接看代码吧。嘿嘿~ /* ** File name: LinkPriorityQueue.h ** Author: ZhouFeng ** Date: 2012/03/30 ** LPQ ...

算法导论学习笔记——最大优先级队列

/** * 最大优先级队列,例如:在一台分时计算机上进行作业高度。这种队列对要执行的各作业及它们之间的相对优先关系加以记录 * 当一个作业做完或被中断时,用extractMax操作从所有等待的作业...
  • FG2006
  • FG2006
  • 2011年08月06日 23:23
  • 900

数据结构——优先级队列(主要是堆)

chapter12 优先级队列, priority queue   在优先级队列中,元素出队列的顺序由元素的优先级决定。   堆是实现优先级队列效率很高的数据结构——堆,是一棵完全二叉树,用数组表...
  • ZDF19
  • ZDF19
  • 2016年12月25日 10:07
  • 614

STL——priority_queue 优先级队列

STL系列之 priority_queue 优先级队列 priority_queue 优先级队列是一个拥有权值概念的单向队列queue,在这个队列中,所有元素是按优先级排列的(也可以认为qu...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:SeqPriorityQueue——顺序优先级队列
举报原因:
原因补充:

(最多只允许输入30个字)