Huffman编码压缩~

实在没动力写下去了，先存个档。 读档时间未定~ 一两天， 一两个月 ， 或者一辈子。

 

Huffman.cpp

#include "stdafx.h"
#include "Huffman.h"
#include <iostream>
#include <math.h>
#include <queue>
#include <stack>
using namespace std;


HuffmanTree::HuffmanTree():m_root(NULL), m_nNode(0), m_nTotalNode(0)
{
    memset(m_code, 0, sizeof(HuffmanCode) * 256);    
}

HuffmanTree::~HuffmanTree()
{
    if(m_root != NULL)
        delete m_root;
    DestoryTree(m_root);
}

Huffman_node* HuffmanTree::CreateNode(unsigned char value, int weight)
{
    Huffman_node* p = new Huffman_node;
    p->weight = weight;
    p->value = value;
    p->leftchild = NULL;
    p->rightchild = NULL;
    p->parent = NULL;
    
    return p;
}

int HuffmanTree::DestoryTree(Huffman_node* root)
{
    queue<Huffman_node*> qNode;
    Huffman_node* temp;

    qNode.push(root);
    while(!qNode.empty())
    {
        temp = qNode.front(); 
        qNode.pop();
        if(temp->leftchild != NULL)
            qNode.push(temp->leftchild);
        if(temp->rightchild != NULL)
            qNode.push(temp->rightchild);
        delete temp;
    }

    return true;
}

Huffman_node* HuffmanTree::MergeNode(Huffman_node* first, Huffman_node* sencond)
{
    Huffman_node* root = CreateNode(0, first->weight + sencond->weight);
    root->leftchild = first;
    root->rightchild = sencond;
    first->parent = root;
    sencond->parent = root;

    return root;
}

Huffman_node* HuffmanTree::BuildHuffmanTree(void* buf, int len)
{
    long                    Table[256] = {0};
    int                        count;
    Huffman_node*            minimal[2];
    Huffman_node*            temp;
    priority_queue<Huffman_node*>    nodelist;

    for(int i = 0; i < len; i++)
    {
        Table[((unsigned char*)buf)[i]] += 1;
    }
    
    for(int i = 0; i < 256; i++)
    {
        if(Table[i] != 0)
        {
            temp = CreateNode(i, Table[i]);
            nodelist.push(temp);
            m_leaves.push_back(temp);
        }
    }
    
    m_nNode = nodelist.size();
    m_nTotalNode = m_nNode * 2 - 1;

    Huffman_node* root;
    while(1)
    {
        //找到2个权值最小的节点
        minimal[0] = nodelist.top();
        nodelist.pop();

        minimal[1] = nodelist.top();
        nodelist.pop();

        root = MergeNode(minimal[0], minimal[1]);
        if(nodelist.empty())
            break;
        nodelist.push(root);
    }

    return root;
}

void PrintTree(Huffman_node* root)
{
    //if(root->leftchild == NULL)
}

int HuffmanTree::IsLeftChild(Huffman_node* node)
{
    if(node->parent == NULL)
        return -1;
    if(node->parent->leftchild == node)
        return 1;
    else
        return 0;
}

int HuffmanTree::CovertBits(vector<char> vecBits, void* code_buf)
{
    int len = 0;
    for(int i = 0; i < vecBits.size(); i += 8)
    {
        int num = 0;
        for(int j = 0; j < 8; j++)
        {
            num += (vecBits[i+j] * (int)pow(2.0,7-j));    
        }
        ((unsigned char*)code_buf)[len++] = num;
    }

    return len;
}


void HuffmanTree::GenerateCode(Huffman_node* root)
{
    vector<Huffman_node *>::iterator iter;

    for(iter = m_leaves.begin(); iter != m_leaves.end(); iter++)
    {
        Huffman_node* temp = *iter;
        char c = temp->value;

        while(temp != m_root)
        {
            if(IsLeftChild(temp))
                m_code[c].bit.push_back(0);
            else
                m_code[c].bit.push_back(1);
            temp = temp->parent;
        }
    }
}


int HuffmanTree::_Code(void* buf, int len, void* code_buf)
{
    vector<char> bits;

    code_buf = new unsigned char[len + 1];
    m_root = BuildHuffmanTree(buf, len);
    
    //生成Huffman编码,编码是反向的,使用的时候逆向输出.
    GenerateCode(m_root);

    for(int i = 0; i< len; i++)
    {
        unsigned char c = ((unsigned char *)buf)[i];
        bits.insert(bits.end(), m_code[c].bit.rbegin(), m_code[c].bit.rend());
    }

    int rest = bits.size() % 8;
    if(rest)
    {
        for(int i = 0; i < (8-rest); i++)
            bits.push_back(0);
    }

    int code_len = CovertBits(bits, code_buf);

    return code_len;
}


int HuffmanTree::_Decode(void* buf, int len, void* decode_buf)
{
    return 0;
}

Huffman.h

#include<vector>
using namespace std;

struct Huffman_node
{
	unsigned char value;
	int weight;
	Huffman_node* parent;
	Huffman_node* leftchild;
	Huffman_node* rightchild;

public:
	Huffman_node operator=(Huffman_node &x)
	{
		value		= x.value;
		weight		= x.weight;
		parent		= x.parent;
		leftchild	= x.leftchild;
		rightchild	= x.rightchild;
		
		return *this;
	}

	friend bool operator<(Huffman_node& first, Huffman_node& second)
	{
		return first.weight < second.value;
	}
};


struct HuffmanCode
{
	unsigned char value;
	vector<char> bit;
};

struct HuffmanCode_header
{
	unsigned int sign;		// 特征
	long compressSize;		// 压缩后大小
	long uncompressSize;	// 未压缩前大小
	unsigned int reserved;	// 保留
	unsigned int version;	// 版本
};

class HuffmanTree
{
private:
	Huffman_node* CreateNode(unsigned char value, int weight);
	int DestoryTree(Huffman_node* root);
	Huffman_node* MergeNode(Huffman_node* first, Huffman_node* sencond);
	Huffman_node* BuildHuffmanTree(void* buf, int len);
	void GenerateCode(Huffman_node* root);
	int IsLeftChild(Huffman_node* node);
	int CovertBits(vector<char> vecBits, void* code_buf);
	int _Code(void* buf, int len, void* code_buf);
	int _Decode(void* buf, int len, void* decode_buf);
	int LoadTreeFromFile();
	int SaveTreeToFile();

public:
	HuffmanTree();
	~HuffmanTree();
	

public:
	int m_nNode;
	int m_nTotalNode;
	Huffman_node* m_root;
	HuffmanCode m_code[256];
	vector<Huffman_node*> m_leaves;
};