优先级队列(priorityqueue)是0个或多个元素的集合,每个元素都有一个优先权,对优先级队列执行的操作有(1)查找(2)插入一个
新元素
(3)删除一般情况下,查找操作用来搜索优先权最大的元素,删除操作用来删除该元素。对于优先权相同的元素,可按先进先出次序处理或按任意优先权进行。
优先级队列 是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。队列下方的数组用二叉树来处理.
AfxStd.h
#pragma once
#ifndef AFXSTD_H
#define AFXSTD_H
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#endif // !AFXSTD_H
heap.h
#pragma once
#include"AfxStd.h"
#ifndef HEAP_H
#define HEAP_H
void MeakHeap(int *arr, int length);
void AdjustHeap_Down(int *arr, int start, int end);
void AdjustHeap_Up(int *arr, int start);
#endif // !HEAP_H
PerioryQueue.h
#pragma once
#include"heap.h"
#ifndef PERIORYQUEUE_H
#define PERIORYQUEUE_H
typedef int ElemType;
const int size = 20;
typedef struct PriorityQueue
{
int capacity;
int cursize;
ElemType *elements;
}*PriQueue;
void InitQueue(PriorityQueue &p);
void DestoryQueue(PriorityQueue &p);
void ClearQueue(PriorityQueue &p);
bool EmptyQueue(PriorityQueue &p);
bool FullQueue(PriorityQueue &p);
bool InsertQueue_Arr(PriorityQueue &p,ElemType *e,int length);
bool EnQueue(PriorityQueue &p,ElemType e);
bool DeQueue(PriorityQueue &p,ElemType &temp);
ElemType GetFront(PriorityQueue &p);
#endif // !PERIORYQUEUE_H
heap.cpp
#include"heap.h"
/*制堆函数,将给定的数组变成最小堆*/
void MeakHeap(int *arr, int length)
{
if (arr == NULL)
{
return;
}
for (int i = (length -1)/2; i >= 0; i--)/*从第一个非叶子节点从下至上,从右至左调整结构*/
{
AdjustHeap_Down(arr, i, length - 1); /*调整函数中传入了数组,起始坐标,末尾坐标*/
}
}
//AdjustHeap_Down,向下调整函数.作用是将数组转化为逻辑上的大堆,
//从而方便升序排序,如果要降序排序,该制堆函数将数组转化为小堆即可.
void AdjustHeap_Down(int *arr, int start, int end)
{
int i = start;
int j = 2 * i + 1;
int temp = arr[i];
while (j <= end)
{
if (j + 1 <= end && arr[j]<arr[j + 1])
{
j++;
}
if (arr[j]>temp)
{
arr[i] = arr[j];
i = j;
j = 2 * i + 1;
}
else
{
break;
}
}
arr[i] = temp;
}
//Up,向下调整函数.作用是向上回溯使其符合小堆,也可稍作修使其符合大堆.
void AdjustHeap_Up(int *arr, int start)
{
int i = start;
int j = (start-1)/2;
int temp = arr[i];
while (j >=0)
{
if (arr[j]>temp)
{
arr[i] = arr[j];
i = j;
j = (j - 1) / 2;
}
else
{
break;
}
}
arr[i] = temp;
}
PerioryQueue.cpp
#include"PerioryQueue.h"
/*初始化队列*/
void InitQueue(PriorityQueue &p)
{
p.elements = (ElemType *)malloc(sizeof(ElemType)*size);
p.cursize = 0;
p.capacity = 20;
}
/*摧毁队列*/
void DestoryQueue(PriorityQueue &p)
{
free(p.elements);
p.cursize = p.capacity = 0;
}
/*清空队列*/
void ClearQueue(PriorityQueue &p)
{
p.cursize = 0;
}
/*判空*/
bool EmptyQueue(PriorityQueue &p)
{
return p.cursize == 0;
}
/*判满*/
bool FullQueue(PriorityQueue &p)
{
return p.cursize == p.capacity;
}
/*将一个长度为length的数组入队*/
bool InsertQueue_Arr(PriorityQueue &p,ElemType *e,int length)
{
if (p.cursize + length > p.capacity)
{
return false;
}
for (int i=0;i<length;i++)
{
p.elements[p.cursize + i] = e[i];
}
p.cursize += length;
MeakHeap(p.elements,p.cursize);
return true;
}
/*入队*/
bool EnQueue(PriorityQueue &p, ElemType e)
{
if (FullQueue(p))
{
return false;
}
p.elements[p.cursize]=e;
p.cursize++;
AdjustHeap_Up(p.elements,p.cursize-1);
return true;
}
/*出队*/
bool DeQueue(PriorityQueue &p, ElemType &temp)
{
if (EmptyQueue(p))
{
return false;
}
temp = GetFront(p);
if (p.cursize > 1) {
p.elements[0] = p.elements[p.cursize - 1];
}
p.cursize--;
AdjustHeap_Down(p.elements,0, p.cursize - 1);
return true;
}
/*取得队首元素*/
ElemType GetFront(PriorityQueue &p)
{
return p.elements[0];
}
main.cpp
#include"PerioryQueue.h"
int main()
{
int arr[] = { 8,18,12,34,90,56,45,78 };
PriorityQueue p;
InitQueue(p);
EnQueue(p,2);
EnQueue(p,3);
InsertQueue_Arr(p,arr,8);
int temp;
int n = p.cursize;
for (int i = 0; i < n; i++)
{
DeQueue(p,temp);
printf("%d\t",temp);
}
return 0;
}