数据结构(六)霍夫曼树与编码

1、算法流程

(1)构建霍夫曼树：自底向上

根据统计频率构建霍夫曼树：

 A、把所有的节点扔进排序队列queue中；

 B、从queue选择选择前面两个最小的元素a、b，把最小的树a作为左节点，把最小的b作为右节点，以此构建父节点c(c的频率值为a+b的频率值)，然后把a、b从队列删除、把c节点插入队列；

 C、循环(A)、(B)步骤构建霍夫曼树，直到queue为空。

(2)编码阶段：自顶向下

 A、除了树的根节点没有码值之外，其他的根据左右子节点进行编码，做节点编码为0，右节点编码为1；

 B、子节点在父节点码值的基础上，在后面加上一位对应的码值。

(3)解码阶段：自顶向下解码

 根据给定的码值，从树根开始递归遍历，遇到0向左走，遇到1向又走，直到码值为空或者遇到叶子节点返回。

2、代码实现

#ifndef DATA_STRUCT_TREE_H
#define DATA_STRUCT_TREE_H
#include<vector>
#include <set>
#include <queue>
#include <string>
using namespace std;
class node{
public:
    node(){
        left_child=NULL;
        right_child=NULL;
        frequency=0;
        coding.clear();
        words="";
    };
    ~node(){};

    node* left_child;
    node* right_child;
    int frequency;
    std::vector<bool> coding;
    string words;


public:
    bool operator <(const node& n1) const
    {
        return frequency<n1.frequency;
    }
};
class huffman_coding{
public:
    static void create_tree(std::set<node>&queue,std::vector<node*>&tree){

        while (!queue.empty())
        {
            node *left= new node(*queue.begin());
            queue.erase(queue.begin());
            tree.push_back(left);

            if (!queue.empty())
            {
                node *right=new node(*queue.begin());
                queue.erase(*queue.begin());
                tree.push_back(right);

                node merge;
                merge.frequency=left->frequency+right->frequency;
                merge.left_child=left;
                merge.right_child=right;
                queue.insert(merge);
            }



        }

    }
    //自顶向下编码
    static void huffman_encoding(node*head){

        //广度优先遍历
        std::queue<node*>Q;
        Q.push(head);
        while (!Q.empty())
        {
            node*n=Q.front();
            Q.pop();
            if(n->left_child)
            {
                n->left_child->coding=n->coding;
                n->left_child->coding.push_back(false);
                Q.push(n->left_child);
            }
            if(n->right_child)
            {
                n->right_child->coding=n->coding;
                n->right_child->coding.push_back(true);
                Q.push(n->right_child);
            }

        }
    }
    static string huffman_decoding(node*head,vector<bool>coding)
    {
        if(coding.empty()||!(head->right_child)||!(head->left_child))
            return head->words;
        std::vector<bool>::iterator this_code=coding.begin();


        if(*this_code)//右节点
        {
            coding.erase(this_code);
            return  huffman_decoding(head->right_child,coding);
        }
        else
        {

            coding.erase(this_code);
            return huffman_decoding(head->left_child,coding);
        }





    }

    static  void main(){
        //http://blog.csdn.net/xgf415/article/details/52628073
        int frequency[5]={10,8,3,4,5};
        string words[5]={"B","A","C","D","E"};
        std::set<node>queue;
        for(int i=0;i<5;i++)
        {
            node n;
            n.frequency=frequency[i];
            n.words=words[i];

            queue.insert(n);
        }




        std::vector<node*>tree;
        create_tree(queue,tree);
        huffman_encoding(tree[tree.size()-1]);


        //打印编码结果

        for(std::vector<node*>::iterator it=tree.begin();it!=tree.end();it++)
        {
            if ((*it)->words=="")
                continue;
            std::cout<<(*it)->words<<":";
            for (int i = 0; i <(*it)->coding.size() ; ++i) {
                std::cout<<(*it)->coding[i];
            }
            std::cout<<std::endl;
        }

        //测试解码
        string decode=huffman_decoding(tree[tree.size()-1],tree[0]->coding);
        std::cout<<decode<<":";
        for (int j = 0; j < tree[0]->coding.size(); ++j) {
            std::cout<<tree[0]->coding[j];


        }
        std::cout<<std::endl;





    }
};





#endif //DATA_STRUCT_TREE_H