每日一题25:Hoffman树

17 篇文章 0 订阅

Hoffman树是由David A. Hoffman于1952年在MIT攻读博士学位期间发表的论文《A Method for the Construction of Minimum-Redundancy Codes》中提出的,它的目的寻找一种利用最少量的编码方法表示信息。Hoffman使用自底向上的方法构建了一棵满足要求的树,用这棵树进行的编码叫做Hoffman编码。
用一个节点表示一条信息,每条信息都要知道它们使用的频率,构建Hoffman树时,将每个节点看做只有一个节点的一棵树,这些树组成了一个森林,算法的流程如下:

  1. 在森林中找到具有最小使用频率的两棵树,为这两棵树生成一个新节点,另新节点成为这两棵树的根,构造起一棵新的树,新节点的使用频率为两个孩子节点使用频率之和。
  2. 从森林中删除刚才选择的两棵树,加入新生成的那棵树。
  3. 重复上面两步,知道森林中只剩下一棵树。

算法流程很简单,证明却很难,我看了原始论文即便都没弄明白,也许是英文太差了。虽然不能证明,但是实现上面的算法还是比较简单的,实现中用一个数组保存所有信息,另一个数组保存每条信息的使用频率,Hoffman树的节点就由四项组成,信息在数组中的索引,信息使用的频率,指向节点左孩子、右孩子的指针。这样设计的理由是信息可能复杂,用一个对象表示,那么如果出现赋值,性能就不好,更重要的一个理由是Hoffman树中有两类节点,一类包含信息(叶子节点),一类不包含信息(非叶子结点),这两类通过信息来区分是不方便的,特别是非叶子结点的信息是空的,C++中没有表示空类型的对象,如果节点中保存的是索引,那么-1就表示该节点是一个非叶子结点,非负索引就可以到数组中取得相应的信息和信息出现的频率。这样设计还能带来另一个好处就是可以让Hoffman树更容易的支持插入操作(虽然这个操作不是被使用的可能性比较小)。实现算法的1、2步需要用一个最小堆,我的前一篇博文已经实现了堆数据结构,用到的数组结构也用之前博文实现的Vector结构。

#ifndef _HOFFMAN_H_
#define _HOFFMAN_H_

#include "../include/Vector.h"
#include "../include/Heap.h"
#include "../Utilites/type_traits.h"
#include "../include/Functor.h"

namespace MyDataStructure
{
    template<typename WeightType>
    struct HoffmanNode
    {
        int index;
        WeightType weight;
        HoffmanNode* left;
        HoffmanNode* right;
    };

    //针对HoffmanNode指针特化一个大于比较仿函数,构造
    //最小堆的的时候需要,最小堆中的元素是HoffmanNode
    //型指针
    template<typename WeightType>
    struct greater<HoffmanNode<WeightType>*>
    {
        bool operator ()(HoffmanNode<WeightType>* op1, HoffmanNode<WeightType>* op2)
        {
            return op1->weight > op2->weight;
        }
    };
    template <typename ValueType, typename WeightType>
    class HoffmanTree
    {   
    public:
        typedef typename ParameterTrait<WeightType>::ParameterType WeightParameterType;
        typedef typename HoffmanNode< WeightType>* NodePtr;
        typedef typename HoffmanNode< WeightType> NodeType;
        typedef typename HoffmanTree<ValueType, WeightType> self;
    public:
        HoffmanTree(ValueType values[],WeightType weights[],int count);
        HoffmanTree(const HoffmanTree& rhs);
        self& operator = (const HoffmanTree& rhs);
        ~HoffmanTree();
        void Clear();
        NodePtr GetHead(){ return head; }
    private:
        NodePtr create_node(int index, WeightParameterType weight);
        NodePtr copy_node(const NodePtr node);
        NodePtr merge_node(NodePtr left, NodePtr right);
        void copy(const HoffmanTree& rhs);
        void __copy_tree(NodePtr* dst_node,NodePtr start_node);
        void __clear_tree(NodePtr start_node);
        void create_tree(ValueType values[], WeightType weights[], int count);
        void clear();
    private:
        NodePtr head;
        Vector<ValueType> values;
        Vector<WeightType> weights;
    };

    template<typename ValueType, typename WeightType>
    HoffmanTree<ValueType, WeightType>::HoffmanTree(ValueType values[], WeightType weights[], int count)
    {
        create_tree( values,weights, count);
    }

    template<typename ValueType, typename WeightType>
    HoffmanTree<ValueType, WeightType>::HoffmanTree(const HoffmanTree& rhs)
    {
        clear();
        copy(rhs);
    }

    template<typename ValueType, typename WeightType>
    typename HoffmanTree<ValueType, WeightType>& HoffmanTree<ValueType, WeightType>
        ::operator =(const HoffmanTree& rhs)
    {
        clear();
        copy(rhs);
        return *this;
    }

    template<typename ValueType, typename WeightType>
    HoffmanTree<ValueType, WeightType>::~HoffmanTree()
    {
        clear();
    }

    template<typename ValueType, typename WeightType>
    void HoffmanTree<ValueType, WeightType>::Clear()
    {
        clear();
    }

    template<typename ValueType, typename WeightType>
    typename HoffmanTree<ValueType, WeightType>::NodePtr
        HoffmanTree<ValueType, WeightType>
        ::create_node(int index, WeightParameterType weight)
    {
        NodeType* node = new NodeType;
        node->left = node->right = nullptr;
        node->index = index;
        node->weight = weight;
        return node;
    }

    template<typename ValueType, typename WeightType>
    typename HoffmanTree<ValueType, WeightType>::NodePtr
        HoffmanTree<ValueType, WeightType>
        ::copy_node(const NodePtr node)
    {
        return create_node(node->index, node->weight);
    }

    template<typename ValueType, typename WeightType>
    typename HoffmanTree<ValueType, WeightType>::NodePtr
        HoffmanTree<ValueType, WeightType>
        ::merge_node(NodePtr left, NodePtr right)
    {
        NodeType* node = new NodeType;
        node->left = left;
        node->right = right;
        node->weight = left->weight + right->weight;
        //用index = -1表示这是一个内部节点
        node->index = -1;
        return node;
    }

    template<typename ValueType, typename WeightType>
    void HoffmanTree<ValueType, WeightType>
        ::copy(const HoffmanTree& rhs)
    {
        values = rhs.values;
        weights = rhs.weights;
        __copy_tree(&head, rhs.head);
    }

    template<typename ValueType, typename WeightType>
    void HoffmanTree<ValueType, WeightType>
        ::__copy_tree(NodePtr* dst_node, NodePtr start_node)
    {
        if (start_node == nullptr) *dst_node = nullptr;
        else
        {
            NodeType* node = copy_node(start_node);
            *dst_node = node;
            __copy_tree(&((*dst_node)->left), start_node->left);
            __copy_tree(&((*dst_node)->right), start_node->right);
        }
    }

    template<typename ValueType, typename WeightType>
    void HoffmanTree<ValueType, WeightType>::clear()
    {
        __clear_tree(head);
        values.Clear();
    }

    template<typename ValueType, typename WeightType>
    void HoffmanTree<ValueType, WeightType>
        ::__clear_tree(NodePtr start_node)
    {
        if (start_node == nullptr) return;
        else
        {
            if (start_node->left != nullptr) __clear_tree(start_node->left);
            if (start_node->right != nullptr) __clear_tree(start_node->right);
            delete start_node;
            start_node = nullptr;
        }
    }

    template<typename ValueType, typename WeightType>
    void HoffmanTree<ValueType, WeightType>
        ::create_tree(ValueType values[], WeightType weights[], int count)
    {
        Heap<NodePtr, greater<NodePtr>> minHeap;
        for (int i = 0; i < count; ++i) 
        {
            NodeType* node = create_node(i, weights[i]);
            this->values.PushBack(values[i]);
            this->weights.PushBack(weights[i]);
            minHeap.Insert(node);
        }
        while (minHeap.Size() > 1)
        {
            NodePtr node1,node2;
            //取使用频率最小的树
            minHeap.GetTop(node1);
            //从堆中移除使用频率最小的树
            minHeap.RemoveTop();
            //取使用频率第二小的树
            minHeap.GetTop(node2);
            //从堆中移除使用频率第二小的树
            minHeap.RemoveTop();
            //构造新树
            NodePtr new_node = merge_node(node1, node2);
            //将新树插入最小堆中
            minHeap.Insert(new_node);
        }
        minHeap.GetTop(head);
    }
}

#endif

测试代码:

// HoffmanTest.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "../include/Hoffman.h"
#include <iostream>

using namespace MyDataStructure;
using namespace std;


int _tmain(int argc, _TCHAR* argv[])
{
    char values[] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i','j' };
    float weights[] = { 0.24f, 0.84f, 0.03f, 0.51f, 0.12f, 0.79f, 0.93f, 0.34f, 0.61f, 0.46f };
    HoffmanTree<char, float> H(values,weights,10);
    HoffmanTree<char, float> H1(H);
    HoffmanTree<char, float> H2 = H1;
    float sum = 0.0f;
    for (int i = 0; i < 10; ++i)
    {
        sum += weights[i];
    }
    cout << sum << endl;
    return 0;
}

看看程序运行结果:
这里写图片描述
这是我用调试状态下查看构造出来的Hoffman树画出来的,本来写了一个打印二叉树的程序,但是由于想做到跨平台、支持多种设备迟迟没有做出来,主要是卡在打印字符的这一步,如果哪位小伙伴有好的点子或资料还请推荐给我。虽然程序没写完,但是却收获了不少东西,最重要的收获记录在了前一篇博客里面。

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值