优先队列的实现及其在哈夫曼编码中的应用

一.优先队列的实现

template 
class priorityQueue
{
    public:
        priorityQueue();
        virtual ~priorityQueue();
        void insertQueue(T e);
        T pop();
        int getNumOfQueue(){ return num; }
    protected:
        struct node
        {
            T data;
            node *next;
        };
        node* front;
        node* rear;
        int num;
};

template 
priorityQueue::priorityQueue()
{
    num = 0;
    front = rear = new node;
    rear->next = NULL;
}

template 
priorityQueue::~priorityQueue()
{
    node* p = front->next;
    while(p){
        delete front;
        front = p;
        p = front->next;
    }
    delete front;
}

template 
void priorityQueue::insertQueue(T e)
{
    num++;
    node *p = new node, *temp = front->next, *pre = front;
    p->data = e;
    while(temp && temp->data < e){           //此处若是结构体注意要重载  '<'。
        pre = temp;
        temp = temp->next;
    }
    p->next = temp;
    pre->next = p;
}

template 
T priorityQueue::pop()
{
    num--;
    T e = front->next->data;
    node* p = front->next;
    front->next = p->next;
    delete p;

    return e;
}

二.哈夫曼树的实现：

#include 
#include "priorityQueue.h"
#include 
#include 

using namespace std;

const int MAXSIZE = 256;

struct HfmNode
{
    char key;
    int priority;
    HfmNode *lchild, *rchild;
};

struct codeNode
{
    char key;
    char code[MAXSIZE];
};

bool cmp(HfmNode a, HfmNode b)
{
    return a.priority < b.priority;
}

bool operator < (HfmNode a, HfmNode b)
{
    return a.priority < b.priority;
}

//建立哈夫曼树
HfmNode *buildTree(char *str)
{
    int i;
    int priority[MAXSIZE] = {0};
    priorityQueue  que;
    HfmNode *temp = NULL, *ltemp, *rtemp;

    for(i=0; str[i]; i++)
        priority[str[i]]++;

    for(i=0; ikey = i;
            temp->priority = priority[i];
            temp->lchild = NULL;
            temp->rchild = NULL;
            que.insertQueue(*temp);
        }

    while(que.getNumOfQueue() > 1){
        temp = new HfmNode;
        ltemp = new HfmNode;
        rtemp = new HfmNode;
        *ltemp = que.pop();
        *rtemp = que.pop();
        temp->priority = ltemp->priority + rtemp->priority;
        temp->lchild = ltemp;
        temp->rchild = rtemp;
        que.insertQueue(*temp);
    }

    temp = new HfmNode;
    *temp = que.pop();
    return temp;
}

bool operator < (codeNode a, codeNode b)
{
    return a.code < b.code;
}

//将字符和所对应的编码存放起来
void encode(HfmNode *tree, char *code, int i, priorityQueue  &table)
{
    if(!tree->lchild && !tree->rchild){
        code[i] = '\0';
        codeNode* temp = new codeNode;
        temp->key = tree->key;
        strcpy(temp->code, code);
        table.insertQueue(*temp);
    }
    else{
        if(tree->lchild){
            code[i] = '0';
            encode(tree->lchild, code, i+1, table);
        }
        if(tree->rchild){
            code[i] = '1';
            encode(tree->rchild, code, i+1, table);
        }
    }
}

//打印字符及其对应编码
void printfTable(priorityQueue  table)
{
     while(table.getNumOfQueue() != 0){
        codeNode temp = table.pop();
        cout<lchild, str, i+1);
    if('1' == str[i])
        decode(tree->rchild, str, i+1);
    if(!str[i])
        cout<key;
}
int main()
{
//table 记录了字符及其所对应的编码
    priorityQueue  table;
    char str[MAXSIZE], code[MAXSIZE];
    cin>>str;

    HfmNode *root = buildTree(str);
    encode(root, code, 0, table);

    printfTable(table);

    cout<<"请输入字符所对应的编码：";
    cin>>str;
    cout<<"对应的字符为：";
    decode(root, str, 0);
}