问题 C: 哈夫曼树

原创已于 2022-02-14 17:52:13 修改 · 1k 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#哈夫曼树

于 2022-02-14 17:38:12 首次发布

codeup 专栏收录该内容

111 篇文章

订阅专栏

该博客讨论了两种不同的方法来实现哈夫曼树的构造，并通过计算叶节点权值的乘积之和来展示其应用。第一种方法利用优先队列直接计算，第二种方法则是通过构建哈夫曼树并自顶向下遍历。代码示例分别展示了这两种方法的实现，适用于解决数据压缩和编码问题。

题目描述
哈夫曼树，第一行输入一个数n，表示叶结点的个数。需要用这些叶结点生成哈夫曼树，根据哈夫曼树的概念，这些结点有权值，即weight，题目需要输出所有结点的值与权值的乘积之和。

输入
输入有多组数据。
每组第一行输入一个数n，接着输入n个叶节点（叶节点权值不超过100，2<=n<=1000）。

输出
输出权值。

样例输入

样例输出

10
62

思路一：利用优先队列直接计算。

#include <cstdio>
#include <queue>
using namespace std;

//代表小顶堆的优先队列
priority_queue<int, vector<int>, greater<int>> q;

int main() {
    int n, temp, x, y;
    while (scanf("%d", &n) != EOF) {
        int sum = 0;
        for (int i = 0; i < n; ++i) {
            scanf("%d", &temp);
            q.push(temp);
        }
        while (q.size() > 1) {
            x = q.top();
            q.pop();
            y = q.top();
            q.pop();
            q.push(x + y); //二者之和作为一个新的数加入优先队列
            sum += x + y;
        }
        q.pop();
        printf("%d\n", sum);
    }
    return 0;
}

思路二：构造哈夫曼树，自顶向下遍历。

#include <cstdio>
#include <climits>
#include <algorithm>
using namespace std;

const int maxn = 1010;
struct HuffmanNode {
    int weight, flag;
    int parent, lchild, rchild;
} Node[maxn * 2];

void searchMin(int &a, int &b, int n) {
    int min = INT_MAX;
    //寻找最小数的序号a
    for (int i = 1; i <= n; i++) {
        if (Node[i].parent == 0 && Node[i].weight < min) {
            min = Node[i].weight;
            a = i;
        }
    }
    min = INT_MAX;
    //寻找次小数的序号b
    for (int i = 1; i <= n; i++) {
        if (Node[i].parent == 0 && Node[i].weight < min && i != a) {
            min = Node[i].weight;
            b = i;
        }
    }
    //保证序号a小于序号b
    if (a > b) {
        swap(a, b);
    }
}

int HuffmanCode(int n, int *w) {
    int m = 2 * n - 1;
    //初始化原始n个叶子结点
    for (int i = 1; i <= n; i++) {
        Node[i].parent = Node[i].lchild = Node[i].rchild = 0;
        Node[i].weight = w[i];
    }
    //构建Huffman二叉树
    for (int i = n + 1; i <= m; i++) {
        int a, b;
        searchMin(a, b, i - 1);
        Node[i].lchild = a;
        Node[i].rchild = b;
        Node[i].weight = Node[a].weight + Node[b].weight;
        Node[a].parent = Node[b].parent = i; //标记父节点
    }
    int ans = 0, len = 0;
    while (m) {
        if (Node[m].flag == 0) { //向左
            Node[m].flag = 1; //标记已访问左子树
            if (Node[m].lchild != 0) {
                m = Node[m].lchild;
                len++;
            } else if (Node[m].rchild == 0) { //叶子结点
                ans += Node[m].weight * len;
            }
        } else if (Node[m].flag == 1) { //向右
            Node[m].flag = 2; //标记已访问右子树
            if (Node[m].rchild != 0) {
                m = Node[m].rchild;
                len++;
            }
        } else { //退回
            Node[m].flag = 0;
            m = Node[m].parent;
            --len; //编码长度减1
        }
    }
    return ans;
}

int main() {
    int n, w[maxn];
    while (scanf("%d", &n) != EOF) {
        for (int i = 1; i <= n; i++) {
            scanf("%d", &w[i]);
        }
        int ans = HuffmanCode(n, w);
        printf("%d\n", ans);
    }
    return 0;
}