算法导论--优先队列实现

仔细看了算法导论第六章,想实现里面的优先队列算法,结果调了好半天的bug才调对,写篇博客记录一下,写的不好之处,跪求各位dalao指点。

算法导论中的优先队列使用数组实现的最大堆,我选择的语言是C++,并且用类封装了这个优先队列,话不多说,我就边贴代码边说明吧_(:3 」∠)_

#pragma once
#include
#include
using namespace std;

#define MIN 0
#define PARENT(index) (index / 2)
#define LEFT(index) (index * 2)
#define RIGHT(index) (index * 2 + 1)
#define SWAP(a,b,q) \
    NODE temp = q[a];\
    q[a] = q[b]; \
    q[b] = temp;

typedef struct node{
    int dat;     //数据
    int priority;//优先级
}NODE;

class pQueue{
private:
    int heapsize;   //初始队列长度
    int max;        //队列的初始最大长度(如超过可增长)
    NODE *pQ;       //指向结构体数组的指针
    void heapify(NODE* q, int index);//调整堆
public:
    pQueue(int maxsize);
    ~pQueue();
    void bulidPrioQueue(NODE* arr, int initsize);
    int extractMaxPriority(NODE* q);
    void insert(NODE* q, int dat, int prio);
    void increase_prio(NODE* q, int index, int num);
    void decrease_prio(NODE* q, int index, int num);
    int search(NODE *q,int value);
    void showQueue(NODE *q);
};

首先定义了一个结构体NODE来存储优先队列中的元素(内容见代码注释),由于还没有加模板,我这里假设数据是int型。

除了构造和析构函数,对于优先队列的操作,我这里定义了这些:

bulidPrioQueue:建立优先队列(其实是建立大根堆)
extractMaxPriority:提取优先队列中的根元素,并调整堆
insert:往优先队列中插入一个元素
increase_prio:提升队列中某个元素的优先级
decrease_prio:降低队列中某个元素的优先级
search:根据队列中元素的值找到队列元素的下标
showQueue:其实就是一个按照优先级从大到小的堆排序输出

构造函数中我做了一些初始化:

pQueue::pQueue(int maxsize){
    heapsize = 0;
    pQ = NULL;
    max = maxsize;
}

析构函数中我将指向数组的指针释放,这就意味着申请结构体数组必须用动态申请(malloc,calloc等),不过这不是必须的,似乎在工程中(比如写一个服务器)才需要这么写。(不知道说的对不对/(┐「ε:)/

pQueue::~pQueue(){
    if (pQ != NULL){
        free(pQ);
    }
}

下面是一个关键函数:调整堆。

这个函数由于复用的比较多,给我带来了不少bug,一些零碎的就不提了,尤其要注意的是,由于是优先队列,在优先级相同的情况下,应该尽量保证先入队的先出队,所以前面的两个if语句的顺序不能调换.

void pQueue::heapify(NODE* q, int index){
    int largest = index;
    int l = LEFT(index);
    int r = RIGHT(index);

    if (l <= heapsize && q[l].priority > q[index].priority){
        largest = l;
    }
    if (r <= heapsize && q[r].priority > q[largest].priority){
        largest = r;
    }
    //优先级相同的情况下,左儿子的优先级高于右儿子
    if (largest != index){
        SWAP(largest,index,q);
        heapify(q, largest);//递归调整堆,建议改为循环调整
    }
}

初始化优先队列操作,这个函数从倒数第二排从右往左第一个有儿子的节点开始调整堆,从堆底向堆顶构造大根堆,保证了高优先级在上。

void pQueue::bulidPrioQueue(NODE* arr, int initsize){
    pQ = arr;
    heapsize = initsize;
    for (int i = initsize / 2; i >= 1; i--){
        heapify(pQ, i);
    }
}

提取一个堆顶元素。这个函数类似单步的堆排序操作。

int pQueue::extractMaxPriority(NODE* q){
    if (heapsize > 1){
        SWAP(heapsize, 1, q);
        heapsize--;
        heapify(q, 1);
        return q[heapsize + 1].dat;
    }
    return q[heapsize--].dat;
}

往优先队列中插入一个元素。算法导论中插入操作的思想是先将带插入元素的优先级置为最低(这里是0),放在数组末尾(也就是堆的右下角)然后对这个元素执行优先级提升操作,让它提高到应有的位置。

void pQueue::insert(NODE* q, int dat,int prio){
    if (heapsize < max){
        q[++heapsize].dat = dat;
        q[heapsize].priority = MIN;
    }
    else{
        realloc(q,(++heapsize + 1)*sizeof(NODE));
        q[heapsize].dat = dat;
        q[heapsize].priority = MIN;
        max++;
    }
    increase_prio(q, heapsize, prio);
}

优先级提升操作。这个操作很关键,它一定程度上保证了同优先级元素,后入队的后出队。(但也不是一定能保证,比如数组中的元素优先级为:3,2,3。这时插入一个优先级为3的元素,那么由于提升优先级的操作,数组将变成这样:3,3(新插入的),3,2。这时新插入的元素在左儿子,用类似堆排序的方法打印队列的时候,新插入的高优先级元素可能会“插队”。这似乎没什么好的办法解决,dalao们有什么好办法请指教!

void pQueue::increase_prio(NODE* q, int index,int prio){
    int p = PARENT(index);
    if (p == 0){
        //说明是第一个元素,没有父母
        cout << "Alread bigest!" << endl;
        return;
    }
    if (prio <= q[index].priority) {
        //优先级没有提升
        cout << "Priotrity need to be bigger!" << endl;
        return;
    }
    q[index].priority = prio;
    while (p >= 1 && prio > q[p].priority){
        //只有优先级大于(不是大于等于)父节点才往上提,这保证了同级之间的先来后到
        SWAP(p, index, q);
        index = p;
        p = PARENT(index);
    }
    return;
}

有升级就自然有降级,降级操作比较简单,关键还是是调整堆的操作。

void pQueue::decrease_prio(NODE* q, int index,int num){
    if (index > heapsize){
        cout << "Out of heapsize!" << endl;
        return;
    }
    q[index].priority = num;
    heapify(q, index);
}

这个按值寻找元素的操作就是简单的遍历数组。

int pQueue::search(NODE *q, int value){
    for (int i = 1; i <= heapsize; i++){
        if (q[i].dat == value){
            return i;
        }
    }
    return 0;
}

另开辟一片内存,将原数组复制过去(不能改变原队列),进行类似堆排序操作,打印优先队列。

void pQueue::showQueue(NODE *q){
    //使用堆排序显示优先队列
    int hz = heapsize;
    NODE * shower = (NODE*)calloc(heapsize+1, sizeof(NODE));
    if (shower != NULL){
        for (int i = 1; i <= heapsize; i++){
            //复制原队列元素到新开的内存进行堆排序
            shower[i].dat = pQ[i].dat;
            shower[i].priority = pQ[i].priority;
        }
        while (heapsize >= 1){
            cout << extractMaxPriority(shower) << ",";
        }
        heapsize = hz;
        free(shower);
    }
    else{
        cout << "Memory fault!" << endl;
    }


}

测试代码

#pragma once
#include"priorityQueue.h"
#define MAXSIZE 10 + 1 //第0号元素不使用,故优先队列最多MAXSIZE - 1个元素
#define VIP1 1
#define VIP2 2
#define VIP3 3
int main(){
    pQueue prioQ(MAXSIZE);
    NODE* arr = NULL;
    int heapsize = 0;
    int top = 0;
    arr = (NODE *)calloc(MAXSIZE, sizeof(NODE));//自动初始化为0,所以用优先级为0作为队列结束标志
    if (arr != NULL){
        //测试数据
        arr[1].dat = 24;
        arr[1].priority = VIP2;
        arr[2].dat = 14;
        arr[2].priority = VIP1;
        arr[3].dat = 317;
        arr[3].priority = VIP3;
        arr[4].dat = 17;
        arr[4].priority = VIP3;
        for (int i = 1; i < MAXSIZE; i++){
            if (arr[i].priority != 0){
                heapsize++;
            }
            else{
                break;
            }
        }
        prioQ.bulidPrioQueue(arr, heapsize);
        prioQ.showQueue(arr);
        cout << endl;
        prioQ.insert(arr, 100, VIP1);
        prioQ.insert(arr, 99, VIP2);
        prioQ.insert(arr, 101, VIP3);
        prioQ.showQueue(arr);
        cout << endl;
        prioQ.increase_prio(arr, prioQ.search(arr, 99), VIP3);
        prioQ.showQueue(arr);
        cout << endl;
        prioQ.decrease_prio(arr, prioQ.search(arr, 99), VIP1);
        prioQ.showQueue(arr);
        cout << endl;
        cout << top << endl;
    }
    else{
        cout << "Memory fault" << endl;
    }
    system("pause");
    exit(0);
}

你可能感兴趣的:(c++数据结构与算法)