递归求解并生成哈夫曼编码的代码实现

一开始我用的三叉链表来生成哈夫曼编码，这一点都不递归。后来我想起了一度被递归统治地恐惧，我发现哈夫曼树不仅编码可以简单的用递归来求，树的WPL也可以。

改善后的递归版本如下，虽然WPL也可以通过递归来求，但我觉得当前的方法更好理解。

#include <iostream>
#include <vector>
#include <stack>
#include <string>
#include <algorithm>

using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::sort;
using std::string;

float WPL = 0.0f;

//二叉链表存储结构
struct _WEIGHTNODE {
    float weight;
    char value;
    struct _WEIGHTNODE *ptrLeft, *ptrRight;

    _WEIGHTNODE(char _input, float _W) {
        weight = _W;
        value = _input;
        ptrLeft = ptrRight = nullptr;
    }

    _WEIGHTNODE() {
        weight = 0.0f;
        value = '?';
        ptrLeft = ptrRight = nullptr;
    }

    //重载输出流
    friend std::ostream &operator<<(std::ostream &output, struct _WEIGHTNODE const *NODE) {
        return output << "Value : " << NODE->value << " --- Weight : " << NODE->weight;
    }
};

typedef struct _WEIGHTNODE NODE;

//用于排序
bool compareWeight(const NODE *n1, const NODE *n2) {
    return n1->weight < n2->weight;
}

//递归求编码
void HuffmanCode(NODE *root, string code) {
    if (root) {
        if (root->value != '#') {
            cout << root->value << " : " << code << endl;
            WPL += root->weight * code.length();
        }
        HuffmanCode(root->ptrLeft, code + "0");
        HuffmanCode(root->ptrRight, code + "1");
    }
}

int main() {
    //存放二叉树的顶点
    vector<NODE *> TotalValues;
    float inputWeight;
    char inputValue;
    //输入数据,遇到问号就停止
    while (cin >> inputValue >> inputWeight) {
        if (inputWeight < 0 || inputValue == '?') {
            break;
        }
        TotalValues.push_back(new NODE(inputValue, inputWeight));
    }

    //遍历所有输入的节点并打印
    for (auto EachMember : TotalValues) {
        cout << EachMember << endl;
    }
    cout << endl << "=== Huffman Code ===" << endl;

    //根据已有节点创建Huffman Tree
    while (TotalValues.size() > 1) {
        //从小到大排序
        sort(TotalValues.begin(), TotalValues.end(), compareWeight);

        //将权重最小的两个点提出
        NODE *tmp1 = *TotalValues.begin();
        TotalValues.erase(TotalValues.begin());

        NODE *tmp2 = *TotalValues.begin();
        TotalValues.erase(TotalValues.begin());

        //合成新节点再放回去
        NODE *CombinedNode = new NODE('#', tmp1->weight + tmp2->weight);
        CombinedNode->ptrLeft = tmp1;
        CombinedNode->ptrRight = tmp2;

        TotalValues.push_back(CombinedNode);
    }

    HuffmanCode(*TotalValues.begin(), "");

    cout << endl << "WPL : " << WPL << endl;

    return 0;
}

以前的那个自作聪明的版本如下

#include <iostream>
#include <vector>
#include <stack>
#include <string>
#include <algorithm>

using std::cin;
using std::cout;
using std::endl;
using std::vector;
using std::sort;
using std::string;

//三叉链表存储结构
struct _WEIGHTNODE {
    float weight;
    char value;
    struct _WEIGHTNODE *ptrLeft, *ptrRight, *ptrParent;

    _WEIGHTNODE(char _input, float _W) {
        weight = _W;
        value = _input;
        ptrLeft = ptrRight = ptrParent = nullptr;
    }

    _WEIGHTNODE() {
        weight = 0.0f;
        value = '?';
        ptrLeft = ptrRight = ptrParent = nullptr;
    }

    //重载输出流
    friend std::ostream &operator<<(std::ostream &output, struct _WEIGHTNODE const *NODE) {
        return output << "Value : " << NODE->value << " --- Weight : " << NODE->weight;
    }
};

typedef struct _WEIGHTNODE NODE;

//通过先序遍历得到当前二叉树的所有叶子节点
void GetLeaf(NODE *root, vector<NODE *> &leaf) {
    if (root) {
        if (root->value != '#') {
            leaf.push_back(root);
        }
        GetLeaf(root->ptrLeft, leaf);
        GetLeaf(root->ptrRight, leaf);
    }
}

//用于排序
bool compareWeight(const NODE *n1, const NODE *n2) {
    return n1->weight < n2->weight;
}

bool compareAlphabet(const NODE *n1,const NODE *n2) {
    return n1->value < n2->value;
}

int main() {
    //存放二叉树的顶点
    vector<NODE *> TotalValues;
    float inputWeight;
    char inputValue;
    //输入数据,遇到问号就停止
    while (cin >> inputValue >> inputWeight) {
        if (inputWeight < 0 || inputValue == '?') {
            break;
        }
        TotalValues.push_back(new NODE(inputValue, inputWeight));
    }

    //遍历所有输入的节点并打印
    for (auto EachMember : TotalValues) {
        cout << EachMember << endl;
    }
    cout << endl << "=== Huffman Code ===" << endl;

    //根据已有节点创建Huffman Tree
    while (TotalValues.size() > 1) {
        //从小到大排序
        sort(TotalValues.begin(), TotalValues.end(), compareWeight);

        //将权重最小的两个点提出
        NODE *tmp1 = *TotalValues.begin();
        TotalValues.erase(TotalValues.begin());

        NODE *tmp2 = *TotalValues.begin();
        TotalValues.erase(TotalValues.begin());

        //合成新节点再放回去
        NODE *CombinedNode = new NODE('#', tmp1->weight + tmp2->weight);
        CombinedNode->ptrLeft = tmp1;
        CombinedNode->ptrRight = tmp2;
        tmp1->ptrParent = tmp2->ptrParent = CombinedNode;

        TotalValues.push_back(CombinedNode);
    }

    //记下生成的Huffman Tree的根节点
    NODE *ptrRoot = *TotalValues.begin();

    if (ptrRoot == nullptr) {
        cout << "Empty BinaryTree" << endl;
        return 0;
    }

    //根据生成的Huffman Tree求各节点的编码
    //存放所有叶子节点
    //从叶子往根逆向求相应编码
    vector<NODE *> leaves;
    GetLeaf(ptrRoot, leaves);

    sort(leaves.begin(),leaves.end(),compareAlphabet);

    //树的带权路径长度
    float WPL = 0.0f;

    for (auto leaf:leaves) {

        char alphe = leaf->value;
        float tmpWPL = leaf->weight;

        string code;
        while (leaf->ptrParent != nullptr) {
            //判断是左节点还是右节点
            if (leaf == leaf->ptrParent->ptrLeft) {
                code = '0' + code;
            } else {
                code = '1' + code;
            }
            leaf = leaf->ptrParent;
        }
        WPL += tmpWPL * code.length();
        cout << alphe << " : " << code << endl;
    }

    cout << endl << "WPL : " << WPL << endl;
    //缺少delete相关功能

    return 0;
}