霍夫曼编码实现

先把代码贴了，有时间再写思路。。

二叉树定义：

binaryTree.h

#ifndef BINARYTREE_H
#define BINARYTREE_H
#include <iostream>
#include "LinkedQueue.h"

template<class T>
class BinaryTree;


int count;

template<class T>
class BinaryTreeNode
{
    friend class BinaryTree < T > ;
    friend void Visit(BinaryTreeNode<T> *);
    friend void InOrder(BinaryTreeNode<T> *);
    friend void PreOrder(BinaryTreeNode<T> *);
    friend void PostOrder(BinaryTreeNode<T> *);
    friend void LevelOrder(BinaryTreeNode<T> *);
public:
    //构造函数
    BinaryTreeNode(){ LeftChild = RightChild = 0; }
    BinaryTreeNode(const T& e){ data = e; LeftChild = RightChild = 0; }
    BinaryTreeNode(const T& e, BinaryTreeNode *l, BinaryTreeNode *r)
    {
        data = e;
        LeftChild = l;
        RightChild = r;
    }

    BinaryTreeNode<T>* GetLeft()const{ return LeftChild; }
    BinaryTreeNode<T>* GetRight()const{ return RightChild; }
    T GetData()const{ return data; }
private:
    T data;
    BinaryTreeNode<T> *LeftChild;//左子树
    BinaryTreeNode<T> *RightChild;//右子树
};

template<class T>
void Visit(BinaryTreeNode<T> *t)
{
    std::cout << t->data << " ";
}

template<class T>
void PreOrder(BinaryTreeNode<T> *t)
{
    if (t)
    {
        Visit(t);
        PreOrder(t->LeftChild);
        PreOrder(t->RightChild);
    }
}

template<class T>
void InOrder(BinaryTreeNode<T> *t)
{
    if (t)
    {
        InOrder(t->LeftChild);
        Visit(t);
        InOrder(t->RightChild);
    }
}

template<class T>
void PostOrder(BinaryTreeNode<T> *t)
{
    if (t)
    {
        PostOrder(t->LeftChild);
        PostOrder(t->RightChild);
        Visit(t);
    }
}

template<class T>
void LevelOrder(BinaryTreeNode<T> *t)
{
    LinkedQueue<BinaryTreeNode<T>*> Q;
    while (t)
    {
        Visit(t);

        if (t->LeftChild)
        {
            Q.Add(t->LeftChild);
        }
        if (t->RightChild)
        {
            Q.Add(t->RightChild);
        }

        if (Q.IsEmpty())
        {
            return;
        }
        Q.Delete(t);

    }
}


template<class T>
class BinaryTree
{
public:
    BinaryTree(){
        root = NULL;
    }

    //复制构造函数
    BinaryTree(const BinaryTree<T> &t);
    ~BinaryTree(){ };//Delete(); };
    bool IsEmpty() const{ return root == NULL };
    bool Root(T& x)const;
    void MakeTree(const T& element, BinaryTree<T>& left, BinaryTree<T>& right);
    void BreakTree(T& element, BinaryTree<T> &left, BinaryTree<T> &right);
    void FreeTree(){ Delete(); };
    void PreOrder(void(*Visit)(BinaryTreeNode<T> *u))const
    {
        PreOrder(Visit, root);
    }
    void InOrder(void(*Visit)(BinaryTreeNode<T> *u))const
    {
        InOrder(Visit, root);
    }
    void PostOrder(void(*Visit)(BinaryTreeNode<T> *u))const
    {
        PostOrder(Visit, root);
    }

    BinaryTreeNode<T>* CopyTree(const BinaryTreeNode<T>* t);//复制树

    void PrintTree()const;
    void LevelOrder(void(*Visit)(BinaryTreeNode<T> *u))const;
    void PreOutput()const;
    void InOutput()const;
    void PostOutput()const;
    void LevelOutput()const;
    void Delete();
    int Height()const
    {
        return Height(root);
    }

    int Size();

    BinaryTreeNode<T>* GetRoot()const{ return root; }
private:
    BinaryTreeNode<T> *root;
    void PreOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)const;
    void InOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)const;
    void PostOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)const;
    int Height(BinaryTreeNode<T> *t)const;


    static void output(BinaryTreeNode<T> *t)
    {
        std::cout << t->data << ' ';
    }

    static void freeNode(BinaryTreeNode<T> *t)
    {
        delete t;
        t = NULL;
    }

    static void ctsize(BinaryTreeNode<T> *t)
    {
        ++count;
    }

};

template<class T>
void BinaryTree<T>::PrintTree()const
{

}

template<class T>
BinaryTreeNode<T>* BinaryTree<T>::CopyTree(const BinaryTreeNode<T>* t)
{
    BinaryTreeNode<T>* Node = NULL;
    if (t)
    {
        BinaryTreeNode<T>* lchild = CopyTree(t->LeftChild);
        BinaryTreeNode<T>* rchild = CopyTree(t->RightChild);
        Node = new BinaryTreeNode<T>(t->data, lchild, rchild);
    }

    return Node;
}

template<class T>
BinaryTree<T>::BinaryTree(const BinaryTree<T> &t)
{
    root = CopyTree(t.root);
}



template<class T>
int BinaryTree<T>::Size()
{
    count = 0;
    PreOrder(ctsize);
    return count;
}

template<class T>
int BinaryTree<T>::Height(BinaryTreeNode<T> *t)const
{
    if (!t)
    {
        return 0;
    }

    int ll = Height(t->LeftChild);
    int lr = Height(t->RightChild);

    if (ll > lr)
    {
        return ++ll;
    }
    else
        return ++lr;
}

template<class T>
bool BinaryTree<T>::Root(T& x) const
{
    if (root)
    {
        x = root->data;
        return true;
    }
    return false;
}

template<class T>
void BinaryTree<T>::MakeTree(const T& element, BinaryTree<T>& left, BinaryTree<T>& right)
{
    if (&left == &right)
    {
        BinaryTree<T> newTree(right);
        if (&left != this)
        {
            root = new BinaryTreeNode<T>(element, left.root, newTree.root);
        }
        else
        {
            BinaryTree<T> newTree2(left);
            root = new BinaryTreeNode<T>(element, newTree2.root, newTree.root);
        }
    }
    else if (&left == this)
    {
        BinaryTree<T> newTree(left);
        root = new BinaryTreeNode<T>(element, newTree.root, right.root);
    }
    else if (this == &right)
    {
        BinaryTree<T> newTree(right);
        root = new BinaryTreeNode<T>(element, left.root, newTree.root);
    }
    else
        root = new BinaryTreeNode<T>(element, left.root, right.root);

    left.root = right.root = NULL;
}

template<class T>
void BinaryTree<T>::BreakTree(T& element, BinaryTree<T> &left, BinaryTree<T> &right)
{
    if (root == NULL)
    {
        std::cerr << "树为空，不能拆分" << std::endl;
        return;
    }

    BinaryTree<T> newTree = *this;
    element = newTree.root->data;
    left.root = newTree.root->LeftChild;
    right.root = newTree.root->RightChild;

    delete root;
    root = NULL;
}

template<class T>
void BinaryTree<T>::PreOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)const
{
    if (t)
    {
        Visit(t);
        cout << endl;
        cout<<"leftChild is: "
        PreOrder(Visit, t->LeftChild);
        PreOrder(Visit, t->RightChild);
    }
}

template<class T>
void BinaryTree<T>::InOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)const
{
    if (t)
    {
        InOrder(Visit, t->LeftChild);
        Visit(t);
        InOrder(Visit, t->RightChild);
    }
}

template<class T>
void BinaryTree<T>::PostOrder(void(*Visit)(BinaryTreeNode<T> *u), BinaryTreeNode<T> *t)const
{
    if (t)
    {
        PostOrder(Visit, t->LeftChild);
        PostOrder(Visit, t->RightChild);
        Visit(t);
    }
}

template<class T>
void BinaryTree<T>::LevelOrder(void(*Visit)(BinaryTreeNode<T> *u))const
{
    LinkedQueue<BinaryTreeNode<T>* > Q;
    BinaryTreeNode<T> *t = root;
    while (t)
    {
        cout << "root is ";
        Visit(t);
        cout << endl;

        if (t->LeftChild)
        {
            Q.Add(t->LeftChild);
            cout << "Leftchild of " << t->data << " is:";
            Visit(t->LeftChild);
            cout << endl;
        }
        else
        {
            cout << t->data << " have no leftchild" << endl;
        }
        if (t->RightChild)
        {
            Q.Add(t->RightChild);
            cout << "Rightchild of " << t->data << " is:";
            Visit(t->RightChild);
            cout << endl;
        }

        else
        {
            cout << t->data << " have no Rightchild" << endl;
        }

        if (Q.IsEmpty())
        {
            return;
        }
        Q.Delete(t);
    }
}

template<class T>
void BinaryTree<T>::PreOutput()const
{
    PreOrder(output, root);
}

template<class T>
void BinaryTree<T>::InOutput()const
{
    InOrder(output, root);
}

template<class T>
void BinaryTree<T>::PostOutput()const
{
    PostOrder(output, root);
}

template<class T>
void BinaryTree<T>::LevelOutput()const
{
    LevelOrder(output);
}

template<class T>
void BinaryTree<T>::Delete()
{
    PostOrder(freeNode, root);
    root = NULL;
}
#endif

队列定义：

LinkedQueue.h:

#ifndef LINKEDQUEUE_H
#define LINKEDQUEUE_H
#include <iostream>
#include <new>
#include "exceptionerror.h"

template<class T>
class LinkedQueue;//声明模板类

template<class T>
class Node
{
public:
    friend class LinkedQueue < T > ;//声明为友元，因为需要访问Node的私有成员
    friend std::ostream& operator<<(std::ostream& output, const LinkedQueue<T>& q);
private:
    Node<T> *next;
    T data;
};

template<class T>
class LinkedQueue
{
public:
    LinkedQueue():front(0),rear(0){}
    ~LinkedQueue();
    friend std::ostream& operator<<(std::ostream& output,const LinkedQueue<T>& q)
    {
        if (q.IsEmpty())
        {
            output << "empty queue" << std::endl;
        }
        else
        {
            Node<T>* p = q.front;
            while (p)
            {
                output << p->data << " ";
                p = p->next;
            }            
        }

        return output;
    }
    bool IsEmpty()const{ return front == 0; }
    bool IsFull()const;
    T First()const;//返回第一个元素
    T Last()const;//返回最后一个元素
    LinkedQueue<T>& Add(const T& x);//添加元素
    LinkedQueue<T>& Delete(T& x);//删除元素
    int Quantity()const;//返回元素个数
private:
    Node<T> *front;
    Node<T> *rear;
};

template<class T>
LinkedQueue<T>::~LinkedQueue()
{
    Node<T>* next;
    while (front)
    {
        next = front->next;
        delete front;
        front = next;
    }
}

template<class T>
bool LinkedQueue<T>::IsFull()const
{
    Node<T>* p;
    try
    {
        p = new Node<T>;
        delete p;
        return false;
    }
    catch (CMemoryException* e)
    {
        return true;
    }
}

template<class T>
T LinkedQueue<T>::First()const
{
    if (IsEmpty())
    {
        throw OutofBounds();
    }

    return front->data;
}

template<class T>
T LinkedQueue<T>::Last()const
{
    if (IsEmpty())
    {
        throw OutofBounds();
    }

    return rear->data;
}

template<class T>
LinkedQueue<T>& LinkedQueue<T>::Add(const T& x)
{
    Node<T> *p = new Node<T>;
    p->data = x;
    p->next = 0;
    if (front)
    {
        rear->next = p;
    }
    else front = p;

    rear = p;
    return *this;
}

template<class T>
LinkedQueue<T>& LinkedQueue<T>::Delete(T& x)
{
    if (IsEmpty())
    {
        throw OutofBounds();
    }
    x = front->data;
    Node<T>* p = front;//为了释放front空间
    front = front->next;
    delete p;

    return *this;
}

template<class T>
int LinkedQueue<T>::Quantity()const
{
    if (IsEmpty())
    {
        return 0;
    }
    int count = 0;
    Node<T>* p = front;
    while (p)
    {
        p=p->next;
        count++;
    }

    return count;
}
#endif

exceptionerror.h:

#ifndef EXCEPTIONERROR_H
#define EXCEPTIONERROR_H
#include <iostream>
class OutofBounds
{
public:
    OutofBounds()
    {
        std::cerr << "Out of Bounds" << std::endl;
        //std::exit(1);
    }
};

class NoMem
{
public:
    NoMem(){
        std::cerr << "No Memory" << std::endl;
        //std::exit(1);
    }

};
#endif

最小堆：

MinHeap.h

#ifndef MinHeap_H
#define MinHeap_H

#include<iostream>
#include<algorithm>
#include "exceptionerror.h"
using namespace std;

template<typename T>
class MinHeap
{

public:
    MinHeap(int MaxHeapSize = 10);
    ~MinHeap()
    {
        if (heap!=NULL)
        {
            delete[] heap;
            heap = NULL;
        }
    }

    int Size() const{ return CurrentSize; }
    T Min()
    {
        if (CurrentSize==0)
        {
            throw OutofBounds();
        }

        return heap[1];
    }

    MinHeap<T>& Insert(const T& x);
    MinHeap<T>& DeleteMin(T& x);
    void Initialize(T a[], int size, int ArraySize);
private:
    int CurrentSize;
    int MaxSize;
    T* heap;
};



template<typename T>
MinHeap<T>::MinHeap(int MaxHeapSize=10):MaxSize(MaxHeapSize),CurrentSize(0)
{
    heap = new T[MaxSize + 1];
}

template<typename T>
MinHeap<T>& MinHeap<T>::Insert(const T& x)
{
    size_t index = ++CurrentSize;
    while (index!=1&&x<heap[index/2])
    {
        heap[index] = heap[index / 2];
        index = index / 2;//移向父节点
    }

    heap[index] = x;

    return *this;
}

template<typename T>
MinHeap<T>& MinHeap<T>::DeleteMin(T& x)
{
    if (CurrentSize==0)
    {
        throw OutofBounds();
    }

    x = heap[1];
    if (CurrentSize==1)
    {
        --CurrentSize;
        return *this;
    }
    T temp = heap[CurrentSize--];
    size_t index = 1;
    size_t cindex = 2;
    while(cindex<=CurrentSize)
    {
        if (cindex<CurrentSize&&heap[cindex]>heap[cindex+1])
        {
            ++cindex;
        }

        if (temp<=heap[cindex])
        {
            break;
        }

        heap[index] = heap[cindex];//move down
        index = cindex;
        cindex *= 2;
    }

    heap[index] = temp;
    return *this;
}

template<typename T>
void MinHeap<T>::Initialize(T a[], int size, int ArraySize)
{
    delete[] heap;
    heap = new T[ArraySize + 1];
    MaxSize = ArraySize;
    CurrentSize = size;

    memcpy(heap+1, a, (CurrentSize)*sizeof(T));

    size_t cindex;
    for (size_t index = CurrentSize / 2; index >= 1;--index)
    {
        T temp = heap[index];

        cindex = 2 * index;
        while (cindex<=CurrentSize)
        {
            if (cindex<CurrentSize&&heap[cindex + 1]<heap[cindex])
            {
                ++cindex;
            }

            if (temp<=heap[cindex])
            {
                break;
            }

            heap[cindex/2] = heap[cindex];
            cindex *= 2;
        }
        
        heap[cindex / 2] = temp;        
    }

}
#endif

Huffman.h:

#ifndef HUFFMAN_H
#define HUFFMAN_H
#include<iostream>
#include<fstream>
#include<vector>
#include<string>
#include<stack>
#include<map>
#include<bitset>
#include<iterator>
#include "binaryTree.h"
#include "MinHeap.h"

using namespace std;
const int NUM_CHARS = 256;


struct HuffCode 
{
    unsigned int size;
    bitset<16> b;
};

void create_freq_array(size_t freqs[NUM_CHARS], const string& str);
void print_table(const map<char, HuffCode>& m_table);
void create_header(size_t freqs[NUM_CHARS], const map<char, HuffCode>& m_table, string header, unsigned int size);
BinaryTree<char>& HuffmanTree(size_t freqs[NUM_CHARS]);
size_t huffman_compress(vector<unsigned char>& output, const string& input);
map<char, HuffCode>& create_table( map<char, HuffCode>& m_table, size_t freqs[NUM_CHARS], BinaryTree<char>& x);

size_t compress(map<char, HuffCode>& m_table, unsigned char* compressed, const string& input);
void set_bit(unsigned char* bits, unsigned int pos, unsigned int state);
unsigned int get_bit(unsigned char* bits, unsigned int pos);
unsigned int get_bit(const bitset<16>& b, unsigned int pos);
unsigned int get_bit(unsigned char c, unsigned int pos);
void write_binary(vector<unsigned char>& input, const char* filename);
void read_binary(vector<unsigned char>& output, const char* filename);
size_t huffman_uncompress(const vector<unsigned char>& compressed, vector<unsigned char>& uncompressed);
void uncompress(const BinaryTree<char>& huff_tree, unsigned char* compressed, vector<unsigned char>& uncompress, size_t size);


class Huffman
{
    friend BinaryTree<char>& HuffmanTree(size_t []);
    friend bool operator<(const Huffman& lhs,const Huffman& rhs)
    {
        return lhs.weight < rhs.weight ? true : false;
    }
    friend bool operator<=(const Huffman& lhs, const Huffman& rhs)
    {
        return lhs.weight <= rhs.weight ? true : false;
    }

public:
    operator size_t()const { return weight; }
    Huffman() :weight(0),tree(){};
private:
    BinaryTree<char> tree;
    size_t weight;
};

/************************************************************************/
/*构建霍夫曼树：  
1.建立只包含一个结点的树
2.选取树中权重最小的2棵合并，将合并后的树放入集合中
3.重复2，直到只有一棵树
*/
/************************************************************************/
BinaryTree<char>& HuffmanTree(size_t freqs[NUM_CHARS])
{
    BinaryTree<char> z, zero;

    int count = 0;
    for (int i = 0; i < NUM_CHARS;++i)
    {
        if (freqs[i])
        {
            ++count;
        }        
    }
    Huffman *w = new Huffman[count];

    //建立count棵单节点树
    int index = 0;
    for (int i = 0; i < NUM_CHARS;++i)
    {
        if (freqs[i])
        {
            z.MakeTree(static_cast<char>(i), zero, zero);
            w[index].weight = freqs[i];
            w[index].tree = z;
            index++;
        }        
    }


    MinHeap<Huffman>H(1);
    H.Initialize(w, count, count);//用w初始化最小堆

    Huffman x, y;

    for (int i = 1; i < count;++i)
    {
        //选取权重最小的2棵树
        H.DeleteMin(x);
        H.DeleteMin(y);

        //合并这2棵树
        z.MakeTree(0, x.tree, y.tree);
        x.weight += y.weight;
        x.tree = z;

        //重新插入最小堆
        H.Insert(x);
    }

    H.DeleteMin(x);
    delete[] w;

    return x.tree;
}

//获取字符编码表
map<char,HuffCode>& create_table(map<char,HuffCode>& m_table,size_t freqs[NUM_CHARS],BinaryTree<char>& x)
{    
    //vector<string> path(7);
    vector<BinaryTreeNode<char>* >pPath;//遍历的路径
    BinaryTreeNode<char>* t = x.GetRoot();
    stack<BinaryTreeNode<char>*> s;//遍历所用栈
    string temp;//二进制编码
    BinaryTreeNode<char>* ttemp=NULL;
    //前序遍历的循环模式
    while (t||!s.empty())
    {
        //遍历左子树
        while (t!=NULL)
        {
            if (t->GetLeft()==NULL&&t->GetRight()==NULL)
            {
                m_table[t->GetData()].size=temp.size();
                m_table[t->GetData()].b = bitset<16>(temp);
            }
            s.push(t);
            pPath.push_back(t);

            t = t->GetLeft();
            //左子树存在，编码0
            if (t!=NULL)
            {
                temp += '0';
            }
        }
        
        if (!s.empty())
        {
            t = s.top();
            s.pop();

            ttemp = pPath.back();
            //路径回溯时将路径中与当前节点不同的节点删除
            while(ttemp!=t)
            {
                temp.pop_back();
                pPath.pop_back();
                ttemp = pPath.back();
            }

            t = t->GetRight();
            //右子树存在，编码1
            if (t!=NULL)
            {
                temp += '1';
            }
        }

    }    
    
    //print_table(m_table);
    return m_table;
}


void print_table(const map<char,HuffCode>& m_table)
{
    map<char, HuffCode>::const_iterator cit = m_table.cbegin();
    for (; cit != m_table.cend(); ++cit)
    {
        cout << cit->first << " " ;
        int size = cit->second.size;
        for (int i = size - 1; i >= 0;--i)
        {
            cout << cit->second.b[i];
        }
        cout << endl;
    }
}
//统计字符频率
void create_freq_array(size_t freqs[NUM_CHARS], const string& str)
{
    int i, maxfreq = 0;

    memset(freqs, 0, sizeof(size_t)*NUM_CHARS);
    
    size_t size = str.size();
    for (i = 0; i < size; ++i)
    {
        freqs[(unsigned char)str[i]]++;

        if (freqs[(unsigned char)str[i]]>maxfreq)
        {
            maxfreq = freqs[(unsigned char)str[i]];
        }
    }

    //压缩字节频率
    if (maxfreq>NUM_CHARS)
    {
        for (i = 0; i < NUM_CHARS;++i)
        {
            if (freqs[i]>0)
            {
                freqs[i] = static_cast<int>(freqs[i] * (double)NUM_CHARS / maxfreq + 0.5);
                if (freqs[i]==0)
                {
                    freqs[i] = 1;
                }
            }
        }
    }
}


void print_freqs(size_t freqs[NUM_CHARS])
{
    for (int i = 0; i < NUM_CHARS;++i)
    {
        if (freqs[i])
        {
            cout << "char " << static_cast<char>(i) << " freq: "
                << freqs[i] << endl;
        }
    }
}

void create_header(size_t freqs[NUM_CHARS], const map<char, HuffCode>& m_table, unsigned char* header, unsigned int size)
{
    memcpy(header, &size, sizeof(int));
    

    for (size_t i = 0; i < NUM_CHARS;++i)
    {
        header[sizeof(int)+i] = static_cast<unsigned char>(freqs[i]);
    }

}

size_t huffman_compress(vector<unsigned char>& compressed, const string& input)
{
    size_t freqs[NUM_CHARS];
    create_freq_array(freqs, input);

    print_freqs(freqs);
    BinaryTree<char> huff_tree;

    huff_tree = HuffmanTree(freqs);
    map<char, HuffCode> m_table;
    create_table(m_table, freqs, huff_tree);
    print_table(m_table);

    unsigned int headersize = sizeof(int) + NUM_CHARS;
    unsigned char* header = new unsigned char[headersize];
    create_header(freqs, m_table, header, input.size());

    unsigned char* comstr = new unsigned char[input.size()];
    memset(comstr, 0, sizeof(char)*input.size());
    size_t codesize = compress(m_table, comstr, input);

    cout << "compressed string size(in byte): " << codesize << endl;

    for (size_t i = 0; i < 8 * codesize;++i)
    {
        cout << get_bit(comstr, i);
    }
    cout << endl;

    for (size_t i = 0; i < headersize;++i)
    {
        compressed.push_back(header[i]);
    }
    for (size_t i = 0; i < codesize;++i)
    {
        compressed.push_back(comstr[i]);
    }
    

    delete[] header;
    delete[] comstr;
    huff_tree.FreeTree();
    return headersize+codesize;
}

// set the bit at position pos in the array bits to the value state
void set_bit(unsigned char* bits, unsigned int pos, unsigned int state)
{
    unsigned char mask = 0x80;  // = 128 dec = 10000000 bin
    for (unsigned int i = 0; i < (pos % 8); i++)
        mask = mask >> 1;  // shift bitmask to right

    if (state)
        bits[pos / 8] = bits[pos / 8] | mask;
    else
        bits[pos / 8] = bits[pos / 8] & (~mask);

    return;
}


// get the state of the bit at position pos in the array bits
unsigned int get_bit(const bitset<16>& b, unsigned int pos)
{

    return b[pos];
}

unsigned int get_bit(unsigned char* bits,unsigned int pos)
{
    unsigned char mask = 0x80;  // = 128 dec = 10000000 bin
    /*
    for (unsigned int i = 0; i < (pos % 8); i++)
        mask = mask >> 1;  // shift bitmask to right
        */
    mask = mask >> (pos % 8);

    return (((mask & bits[(int)(pos / 8)]) == mask) ? 1 : 0);
}

unsigned int get_bit(unsigned char c,unsigned int pos)
{
    unsigned char mask = 0x80;
    mask = mask >> (pos % 8);

    return (mask&c) == mask ? 1 : 0;
}
size_t compress(map<char, HuffCode>& m_table, unsigned char* compressed, const string& input)
{
    size_t size = input.size();
    char c;
    size_t pos = 0;
    for (size_t i = 0; i < size;++i)
     {
         c = input[i];
         for (size_t j = 0; j < m_table[c].size;++j)
         {
             set_bit(compressed, pos + j, get_bit(m_table[c].b, m_table[c].size-1-j));
         }

         pos += m_table[c].size;
     }

    /*
    for (size_t i = 0; i < pos; ++i)
    {
        cout << get_bit(compressed, i);
    }
    cout << get_bit(compressed, pos + 1);
    cout << get_bit(compressed, pos + 1);
    cout << endl;
    */
    return (pos / 8 + 1);
}

void write_binary(vector<unsigned char>& input, const char* filename)
{
    ofstream out(filename, ofstream::binary);
    out.clear();
    
    if (out)
    {
        copy(input.begin(), input.end(), ostream_iterator<unsigned char>(out));
        out.close();
    }
    
}

void read_binary(vector<unsigned char>& output, const char* filename)
{
    unsigned char c;
    ifstream in("test.bin", ifstream::binary);
    if (in)
    {
        while (!in.eof())
        {
            c = in.get();
            output.push_back(c);
        }
        in.close();
    }
}

size_t huffman_uncompress(const vector<unsigned char>& compressed, vector<unsigned char>& uncompressed)
{
    unsigned int freqs[NUM_CHARS];
    unsigned int headersize = sizeof(int) + NUM_CHARS;
    size_t size = 0;
    unsigned char* comp = new unsigned char[compressed.size()];
    for (size_t i = 0; i < compressed.size();++i)
    {
        comp[i] = compressed[i];
    }
    memcpy(&size, comp, sizeof(int));

    cout << "size of compressed string(in byte): " << size << endl;
    
    for (int i = 0; i < NUM_CHARS;++i)
    {
        freqs[i] = (unsigned int)comp[sizeof(int) + i];
    }

    BinaryTree<char> huff_tree;
    huff_tree = HuffmanTree(freqs);
    uncompress(huff_tree, comp + headersize, uncompressed, size);
    huff_tree.FreeTree();
    delete[]comp;
    
    return size;
}

void uncompress(const BinaryTree<char>& huff_tree, unsigned char* compressed, vector<unsigned char>& uncompress, size_t size)
{
    size_t length = 0;
    unsigned int pos = 0;
    unsigned int bit;

    BinaryTreeNode<char>* pNode = NULL;
    while (length<size)
    {
        pNode = huff_tree.GetRoot();
        while (pNode->GetLeft()!=NULL&&pNode->GetRight()!=NULL)
        {
            bit = get_bit(compressed, pos++);
            if (bit)
            {
                pNode = pNode->GetRight();
            }
            else
                pNode = pNode->GetLeft();
        }

        uncompress.push_back(pNode->GetData());
        ++length;
    }
}

#endif

附上一篇比较好的介绍文档：

http://pan.baidu.com/s/1gdF3LGB