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跳出循环。

C++优先级队列中,比较函数使用的两种情况:

-------------------------------------典型例题1  :C++优先级队列中,比较函数使用的两种情况:---------------------------------...
  • haiping_3
  • haiping_3
  • 2009年09月25日 09:55
  • 1681

顺序优先级队列

初学数据结构,一个小程序 SeqPQueue.h typedef struct DataType { ElemType elem; //数据元素 int pri...
  • lingfeng892
  • lingfeng892
  • 2012年05月13日 11:11
  • 248

Python利用heapq实现一个优先级队列

实现一个优先级队列,每次pop的元素要是优先级高的元素,由于heapq.heapify(list)默认构建一个小顶堆,因此要将priority变为相反数再push,代码如下:import heapq ...
  • Jmiew123
  • Jmiew123
  • 2017年04月02日 10:43
  • 509

RabbitMQ使用场景练习:优先级队列(十)

优先级队列      只有当消费者不足,不能及时进行消费的情况下,优先级队列才会生效       RabbitMQ3.5以后已经集成了rabbitmq_priority_queue  引...
  • azhegps
  • azhegps
  • 2016年12月22日 15:32
  • 1586

优先级队列是一种什么样的数据结构

优先级队列(PriprityQueue)是一种无界队列,基于优先级堆,它的元素根据自然顺序或者通过实现Comparator接口的自定义排序方式进行排序。这篇文章,我们将创建一个Items的优先级队列,...
  • chuntiandejiaobu10
  • chuntiandejiaobu10
  • 2016年09月07日 20:52
  • 758

优先级队列几个应用详解

优先级队列区别于普通队列的一点是:优先级队列如果插入的节点是结构体类型,则要在结构体中重载比较操作符函数。示例代码如下: //优先级队列的使用测试 //优先级队列跟对列的使用方式的区别是优先级队...
  • liuzhanchen1987
  • liuzhanchen1987
  • 2012年08月12日 13:52
  • 7391

一个作业调度程序,采用的链式优先级队列

                      以前编的一个使用链式优先级队列的作业调度程序,也是比较简单的。#includeiostream>#includeassert.h>using namespa...
  • lsk_30516
  • lsk_30516
  • 2006年12月19日 09:23
  • 1486

用java实现优先级别队列

1、注意:因优先级别最高的元素被删除后,其后边的数都会往前移动,所以不会出现“假溢出”。所以不用设计成循环队列2、包和类的结构截图:3package com.test3;public class El...
  • liangyihuai
  • liangyihuai
  • 2015年09月15日 13:45
  • 396

第十章·优先级队列

需求与动机什么是优先级队列 优先队列是计算机科学中的一类抽象数据类型。优先队列中的每个元素都有各自的优先级,优先级最高的元素最先得到服务;优先级相同的元素按照其在优先队列中的顺序得到服务。优先队列...
  • xiang_freedom
  • xiang_freedom
  • 2016年04月22日 00:53
  • 4144

【STL学习】优先级队列Priority Queue详解与C++编程实现

优先级队列Priority Queue介绍 优先级队列是一个拥有权值观念的queue。它允许在底端添加元素、在顶端去除元素、删除元素。 优先级队列内部的元素并不是按照添加的顺序排列,而是自...
  • xiajun07061225
  • xiajun07061225
  • 2013年01月30日 16:43
  • 14124
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:SeqPriorityQueue——顺序优先级队列
举报原因:
原因补充:

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