【数据结构】模拟实现一个哈夫曼树

最新推荐文章于 2020-06-07 17:58:15 发布

sofia_m

最新推荐文章于 2020-06-07 17:58:15 发布

阅读量448

点赞数 1

CC 4.0 BY-SA版权

分类专栏：数据结构文章标签：哈夫曼树

本文链接：https://blog.youkuaiyun.com/sofia_m/article/details/81143743

数据结构专栏收录该内容

28 篇文章

订阅专栏

本文详细介绍了霍夫曼树的构建过程，包括使用自定义堆结构进行节点管理的方法，并通过模板实现通用性，适用于不同数据类型。文章还提供了完整的源代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

实现源码：

#pragma once
#include<iostream>
#include<vector>
#include"Heap.h"
using namespace std;

//存放HuffTree节点信息
template<class T>
struct HuffNode{
public:
    HuffNode(const T& t = T())
        :_weight(weight)
        , _pLeft(NULL)
        , _pRight(NULL)
        , _pParent(NULL)
    {}

    //当_pParent=NULL --> 该树还是森林中的一颗子树，还没有归并到别的树里面去
    //否则_pParent!=NULL -->该树已经是某棵树的子树了
    T _weight;//权值
    HuffNode<T>* _pLeft;
    HuffNode<T>* _pRight;
    HuffNode<T>* _pParent;
};

template<class T>
class HuffTree{
    typedef HuffNode<T> Node;
    typedef Node* pNode;

public:
    HuffTree()
        :_root(NULL)
    {}

    HuffTree(const T arr[], size_t size, const T& invalid){

        _CreateHuffManTree(arr, size, invalid);

    }

    ~HuffTree(){
        _DestroyTree(_root);
    }


private:
    void _CreateHuffManTree(T* arr, size_t size, const T& invalid){
        //invalid ->  无效值
        struct Compare{
            bool operator()(pNode pLeft, pNode pRight){
                if (pLeft->_weight < pRight->_weight)
                    return true;
                return false;
            }
        };
        Heap<pNode, Compare> hp;
        //1.创建二叉树森林

        for (size_t i = 0; i < size; i++){
            if (arr[i] != invalid)
                hp.Push(new Node(arr[i]));
        }

        if (hp.Empty()){
            _root = NULL:
            return;
        }

        //2.
        while (hp.Size() > 1){
            pNode pLeft = hp.Top();
            hp.Pop();

            pNode pRight = hp.Top();
            hp.Pop;

            pNode parent = new Node(pLeft->_weight + pRight->_weight);
            parent->_pLeft = pLeft;
            pLeft->_pParent = parent;
            parent->_pRight = pRight;
            pRight->_pParent = parent;

            hp.Push(parent);
        }
        _root = hp.Top();
    }

    void _DestoryTree(pNode& pRoot){
        if (pRoot){
            _DestoryTree(pRoot->_pLeft);
            _DestoryTree(pRoot->_pRight);
            delete pRoot;
            pRoot = NULL;
        }
    }

private:
    pNode _root;
};