哈夫曼树以及哈夫曼编码的实现

照搬教材的(

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>

typedef struct {
    unsigned int weight;
    unsigned int parent, lchild, rchild;
} HTNode, *HuffmanTree;

typedef char **HuffmanCode;

unsigned int min1, min2;

void Select(HuffmanTree HT, int e, int *s1, int *s2) {
    min1 = min2 = INT_MAX;
    *s1 = *s2 = 0;

    for (int i = 1; i <= e; ++i) {
        if (HT[i].weight < min1 && !HT[i].parent) {
            min2 = min1;
            *s2 = *s1;
            min1 = HT[i].weight;
            *s1 = i;
        } else if (HT[i].weight < min2 && !HT[i].parent) {
            min2 = HT[i].weight;
            *s2 = i;
        }
    }
    //    printf("%d %d\n", *s1, *s2);
}

void HuffmanCoding(HuffmanTree *HT, HuffmanCode *HC, int *w, int n) {
    if (n <= 1) return;
    int m = 2 * n - 1;  //由叶子结点计算总结点数
    *HT = (HuffmanTree) malloc((m + 1) * sizeof(HTNode));

    int i;
    HuffmanTree p;
    for (p = *HT + 1, i = 1; i <= n; ++i, ++p, ++w)
        p->weight = *w, p->parent = 0, p->lchild = 0, p->rchild = 0;    //不使用0号位
    for (; i <= m; ++i, ++p) p->weight = 0, p->parent = 0, p->lchild = 0, p->rchild = 0;

    p = *HT;
    for (i = n + 1; i <= m; ++i) {
        int s1, s2;
        Select(*HT, i - 1, &s1, &s2);
        p[s1].parent = i;
        p[s2].parent = i;
        p[i].lchild = s1;
        p[i].rchild = s2;
        p[i].weight = p[s1].weight + p[s2].weight;
    }

    //    for (i = 1; i <= m; i++)
    //        printf("%d: %d,%d,%d,%d\n", i, p[i].weight, p[i].parent, p[i].lchild, p[i].rchild);

    *HC = (HuffmanCode) malloc(n + 1 * sizeof(char *)); //分配n个字符编码的头指针向量
    char *cd = (char *) malloc(n * sizeof(char));
    cd[n - 1] = '\0';

    for (i = 1; i <= n; ++i) {
        int start = n - 1;
        for (int c = i, f = (int) p[i].parent; f != 0; c = f, f = (int) p[f].parent)    //从叶子结点到根逆向求编码
            if (p[f].lchild == c) cd[--start] = '0';
            else cd[--start] = '1';

        (*HC)[i] = (char *) malloc((n - start) * sizeof(char));
        strcpy((*HC)[i], &cd[start]);
    }
    //    printf("%s\n", *cd);
    free(cd);
}

int main() {
    HuffmanTree t;
    HuffmanCode c;
    int n, weight[100];

    printf("请输入结点个数:");
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        printf("第%d个结点权值:", i + 1);
        scanf("%d", &weight[i]);
    }

    HuffmanCoding(&t, &c, weight, n);

    printf("编码如下:\n");
    for (int i = 1; i <= n; ++i)
        printf("%d: %s\n", t[i].weight, c[i]);
    return 0;
}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 哈是一种特殊的二叉,用于实现编码。哈编码是一种无损压缩数据的方式,可以将一个字符串或者文件转换为一个“01”序列,使其占用的空间更小。 构造哈的过程首先需要计算每个字符出现的频率,然后将这些字符和频率建立起来一个数组。接着,以这个数组为基础构造哈。具体的步骤是: 1. 将字符和频率存储在一个数组中。 2. 根据频率从小到大排序数组。 3. 取出数组中的前两个元素,将其权值相加生成一个新的节点,将这个节点放回数组中。 4. 重复第三步,直到只剩下一个节点。 5. 最后构造出来的即为哈。 接着,就可以根据哈实现编码了。哈编码规则是:在哈中,从根节点到该字符所在叶子节点的路径中,若经过的左子则输出0,经过的右子则输出1。例如,对于字符串"hello",哈编码为: h: 110, e: 111, l: 01, o: 00。 总之,哈和哈编码是无损压缩算法中的经典算法,在各种压缩领域都有广泛应用。 ### 回答2: 哈是一种型数据结构,可以用来进行数据的压缩和解压缩。构造哈的算法通常采用贪心策略,即在每一步中选择权值最小的两个节点,并将它们合并成一个新的节点,直到形成一个根节点为止。 在构造哈后,可以通过遍历来获取每个字符的编码。具体来说,可以从根节点开始遍历,遇到左子则在编码末尾添加0,遇到右子则在编码末尾添加1,直到达到叶子节点,即可得到该字符的哈编码。 哈编码的主要优势在于其具有变长编码,即不同字符的编码长度可以不同。这比固定长度编码更加高效,因为在压缩稀疏数据时,短编码可以显著减少编码长度。 下面我们来实现编码的具体代码,以字符串"hello world"为例: 1.首先需要统计每个字符出现的次数,并按照出现次数从小到大排序,以便构造哈。 ``` from collections import Counter string = "hello world" counter = dict(Counter(string)) sorted_count = sorted(counter.items(), key=lambda x: x[1]) ``` 2.使用sorted_count中的数据构造哈。 ``` class Node(object): def __init__(self, value, freq): self.value = value self.freq = freq self.left = None self.right = None def build_huffman_tree(sorted_count): nodes = [Node(value=c[0], freq=c[1]) for c in sorted_count] while len(nodes) > 1: node1 = nodes.pop(0) node2 = nodes.pop(0) new_node = Node(value="", freq=node1.freq + node2.freq) new_node.left = node1 new_node.right = node2 nodes.append(new_node) nodes = sorted(nodes, key=lambda x: x.freq) root = nodes[0] return root root = build_huffman_tree(sorted_count) ``` 3.遍历哈,获取每个字符的编码。 ``` def traverse_tree(node, code, codes): if node is None: return if node.value: codes[node.value] = code return traverse_tree(node.left, code + "0", codes) traverse_tree(node.right, code + "1", codes) codes = {} traverse_tree(root, "", codes) print(codes) ``` 输出结果为: ``` {'h': '1110', 'w': '11000', 'r': '11001', 'd': '11010', 'e': '001', ' ': '010', 'l': '000', 'o': '1111'} ``` 这就是"hello world"字符串中每个字符的哈编码。使用这些编码可以非常高效地将原始数据进行压缩。 ### 回答3: 哈是一种经典的形结构,可以用来实现编码。哈编码是一种基于变长编码的数据压缩算法,它利用出现频率较高的字符来用较短的编码来表示,从而实现对数据的压缩。 哈的构造方法是:首先将所有的字符按照出现频率从小到大排序,然后将出现频率最小的两个字符合并成一棵二叉,其权值为两个字符的权值之和。然后将合并后的二叉插入到原来的序列中,重新排序。然后再将出现频率最小的两个字符合并成一棵二叉,以此类推,直到构造出一棵包含所有字符的二叉,这就是哈。 哈编码实现方法是:对于哈上的每一个叶子节点,将其路径上的左右分支分别标记为0和1,得到该叶子节点对应的编码。然后将每个字符对应的编码存储起来,即可得到该字符串的哈编码。 哈编码具有很好的压缩效果,因为它可以使得出现频率较高的字符用较短的编码表示,从而减小了编码的总长度,实现了对数据的压缩。同时,哈编码还具有唯一解的性质,即每个字符都有唯一的编码,从而避免解压缩时出现歧义。因此,哈编码在数据压缩领域得到了广泛的应用。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值