赫夫曼树

赫夫曼编码是该思想的应用，将频率出现较多的字母定义为长度较短的二进制，将出现频率小的定义为长度大的二进制，这样有效的提高了存储能力，赫夫曼树的用处还很多，这种思想可以提高程序运行效率，如在多个判断语句中，可以将访问较多的条件放在第一个位置，减小其访问权重。

#ifndef HUFFMANNODE_H
#define HUFFMANNODE_H
#include <iostream>
using namespace std;
class HuffmanNode
{
public:
    HuffmanNode();
    HuffmanNode(int weight);
    void SetWeight(int weight);
    int GetWeight();
    void SetCode(int weight);
    int GetCode();
    void Display();
    virtual ~HuffmanNode();
    HuffmanNode* leftNode;
    HuffmanNode* rightNode;
    HuffmanNode* parentNode;
protected:
    int          nWeight;
    int          nCode;
private:
};
#endif // HUFFMANNODE_H

 

#ifndef HUFFMANTREE_H
#define HUFFMANTREE_H
#include "./HuffmanNode.h"
#include <vector>
#include <iostream>
using namespace std;

class HuffmanTree
{
public:
    HuffmanTree();
    void CreateDate();
    void CreateTree();
    void PreOrderVisit(HuffmanNode* node);
    virtual ~HuffmanTree();

    HuffmanNode* headNode;
protected:
    int* weight;
    int len;
private:
};

#endif // HUFFMANTREE_H

 

#include "../include/HuffmanNode.h"
HuffmanNode::HuffmanNode()
{
    nWeight = 0;
    nCode = 0;
    leftNode = NULL;
    rightNode = NULL;
    parentNode = NULL;
}
HuffmanNode::HuffmanNode(int weight)
{
    nWeight = weight;
    nCode = 0;
    leftNode = NULL;
    rightNode = NULL;
    parentNode = NULL;
}
void HuffmanNode::SetWeight(int weight)
{
    nWeight = weight;
}
int HuffmanNode::GetWeight()
{
    return nWeight;
}void HuffmanNode::SetCode(int code)
{
    nCode = code;
}
int HuffmanNode::GetCode()
{
    return nCode;
}
void HuffmanNode::Display()
{
    cout<<nCode<<" ";
}
HuffmanNode::~HuffmanNode()
{
    //dtor
}

 

#include "../include/HuffmanTree.h"
#include <vector>
#include <iostream>
using namespace std;
HuffmanTree::HuffmanTree()
{
    weight = NULL;
    len = 0;
    headNode = new HuffmanNode();
}
HuffmanTree::~HuffmanTree()
{
    //dtor
    delete[] weight;
    delete headNode;
}
void HuffmanTree::CreateDate()
{
    len = 6;
    weight = new int[len];//程序在开始时，weight指向不确定位置
    //直到CreateDate运行完成，将所有数据存在连续堆中，然后将weight指向这片区域。
    weight[0] = 10;
    weight[1] = 5;
    weight[2] = 7;
    weight[3] = 8;
    weight[4] = 9;
    weight[5] = 19;
}
void HuffmanTree::CreateTree()
{
    int temp;
    //从小到大排序
    for(int i=0; i<len; i++) {
        for(int j=i; j<len; j++) {
            if(weight[j] < weight[i]) {
                temp = weight[i];
                weight[i] = weight[j];
                weight[j] = temp;
            }
        }
    }
    vector<HuffmanNode> huffNode;
    for(int i=0; i<len; i++) {
        HuffmanNode node(weight[i]);
        huffNode.push_back(node);
    }
    int pos = 0; //记录开始比较的节点位置
    //最小权重两点合一
    while((huffNode.size()-pos)>2) {
        //获得两个最小权重和
        HuffmanNode* node1 = &(huffNode.at(0+pos));
        HuffmanNode* node2 = &(huffNode.at(1+pos));
        int sum = node1->GetWeight()+node2->GetWeight();
        HuffmanNode* node = new HuffmanNode(sum);
//此处node怎么处理析构，程序完了怎么释放？见下。
        node1->SetCode(0);
        node2->SetCode(1);
        node->leftNode = node1;
        node->rightNode = node2;
        node1->parentNode = node;
        node2->parentNode = node;
        pos = pos + 2;
        //将和的节点插入vector
        for(vector<HuffmanNode>::iterator it=(huffNode.begin()+pos)
            ; it !=  huffNode.end(); it++) {
            HuffmanNode tempNode = *it;
            if(sum > tempNode.GetWeight()) {
                if(it == (huffNode.end()-1)) {
                    huffNode.push_back(*node);
                    delete node;//将上边使用的node释放
                    break;
                }
            }
            else {
                    huffNode.insert(it,*node);//插入节点
                    break;
                }
            }
            //显示vector中的节点
        /* for(vector<HuffmanNode>::iterator it=(huffNode.begin())
            ; it !=  huffNode.end(); it++) {
             HuffmanNode tempNode = *it;
             cout<<tempNode.GetWeight()<<" ";
        }*/
    }
    //连接头节点
        HuffmanNode* node1 = &(huffNode.at(0+pos));
        HuffmanNode* node2 = &(huffNode.at(1+pos));
        int sum = node1->GetWeight()+node2->GetWeight();
        headNode->SetWeight(sum);
        node1->SetCode(0);
        node2->SetCode(1);
        headNode->leftNode = node1;
        headNode->rightNode = node2;
        node1->parentNode = headNode;
        node2->parentNode = headNode;
}
void HuffmanTree::PreOrderVisit(HuffmanNode* node)
{
    if(node != headNode) {
        node->Display();
    }
    if(node->leftNode != NULL || node->rightNode != NULL) {
       PreOrderVisit(node->leftNode);
       PreOrderVisit(node->rightNode);
    }
}

 

#include <iostream>
#include "./include/HuffmanTree.h"
using namespace std;
int main()
{
    HuffmanTree huffman;
    huffman.CreateDate();
    huffman.CreateTree();
    huffman.PreOrderVisit(huffman.headNode);
    return 0;
}

 

感觉有点乱，哪位大侠写了huffma，而且比较强大的，分享分享！