C语言实现Huffman树并计算带权路径长度

More Code,More progress微笑


#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef struct _BTreeNode 
{
    ElemType data;
    struct _BTreeNode* left;
    struct _BTreeNode* right;
}BTreeNode;



//根据数组 a 中 n 个权值建立一棵哈夫曼树,返回树根指针
BTreeNode* CreateHuffman(ElemType a[], int n)
{
    int i, j;
    BTreeNode **b, *q;
    b = (BTreeNode **)malloc(n*sizeof(BTreeNode));
    for (i = 0; i < n; i++) //初始化b指针数组,使每个指针元素指向a数组中对应的元素结点
    {
        b[i] =(BTreeNode *) malloc(sizeof(BTreeNode));
        b[i]->data = a[i];
        b[i]->left = b[i]->right = NULL;
    }
    for (i = 1; i < n; i++)//进行 n-1 次循环建立哈夫曼树
    {
        //k1表示森林中具有最小权值的树根结点的下标,k2为次最小的下标
        int k1 = -1, k2;
        for (j = 0; j < n; j++)//让k1初始指向森林中第一棵
  • 3
    点赞
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
哈夫曼树带权路径长度,需要先构建哈夫曼树,然后对中每个叶子节点出它与根节点的路径长度,再将每个叶子节点的路径长度乘上它的权值,最后把所有叶子节点的乘积相加即可得到带权路径长度。 以下是 C 语言实现哈夫曼树带权路径长度的代码示例: ```c #include <stdio.h> #include <stdlib.h> typedef struct node { int weight; struct node *left; struct node *right; } Node; typedef struct heap { int size; int capacity; Node **nodes; } Heap; Node* create_node(int weight) { Node* node = (Node*) malloc(sizeof(Node)); node->weight = weight; node->left = NULL; node->right = NULL; return node; } Heap* create_heap(int capacity) { Heap* heap = (Heap*) malloc(sizeof(Heap)); heap->size = 0; heap->capacity = capacity; heap->nodes = (Node**) malloc(sizeof(Node*) * capacity); return heap; } void swap_node(Node **a, Node **b) { Node *temp = *a; *a = *b; *b = temp; } void heapify(Heap *heap, int index) { int smallest = index; int left = 2 * index + 1; int right = 2 * index + 2; if (left < heap->size && heap->nodes[left]->weight < heap->nodes[smallest]->weight) { smallest = left; } if (right < heap->size && heap->nodes[right]->weight < heap->nodes[smallest]->weight) { smallest = right; } if (smallest != index) { swap_node(&heap->nodes[smallest], &heap->nodes[index]); heapify(heap, smallest); } } void build_heap(Heap *heap) { int n = heap->size; for (int i = n / 2 - 1; i >= 0; i--) { heapify(heap, i); } } Node* extract_min(Heap *heap) { Node* min_node = heap->nodes[0]; heap->nodes[0] = heap->nodes[heap->size - 1]; heap->size--; heapify(heap, 0); return min_node; } void insert(Heap *heap, Node *node) { if (heap->size == heap->capacity) { printf("Heap is full!\n"); return; } heap->size++; int i = heap->size - 1; while (i > 0 && node->weight < heap->nodes[(i - 1) / 2]->weight) { heap->nodes[i] = heap->nodes[(i - 1) / 2]; i = (i - 1) / 2; } heap->nodes[i] = node; } Node* build_huffman_tree(int *weights, int n) { Heap* heap = create_heap(n); for (int i = 0; i < n; i++) { Node* node = create_node(weights[i]); insert(heap, node); } build_heap(heap); while (heap->size > 1) { Node* left = extract_min(heap); Node* right = extract_min(heap); Node* parent = create_node(left->weight + right->weight); parent->left = left; parent->right = right; insert(heap, parent); } Node* root = extract_min(heap); free(heap->nodes); free(heap); return root; } void calculate_wpl(Node* node, int depth, int *wpl) { if (node == NULL) { return; } if (node->left == NULL && node->right == NULL) { *wpl += node->weight * depth; return; } calculate_wpl(node->left, depth + 1, wpl); calculate_wpl(node->right, depth + 1, wpl); } int huffman_wpl(int *weights, int n) { Node* root = build_huffman_tree(weights, n); int wpl = 0; calculate_wpl(root, 0, &wpl); return wpl; } int main() { int weights[] = {1, 3, 2, 7, 5}; int n = sizeof(weights) / sizeof(weights[0]); int wpl = huffman_wpl(weights, n); printf("Huffman tree WPL = %d\n", wpl); return 0; } ``` 在以上示例中,`build_huffman_tree` 函数用于构建哈夫曼树,`calculate_wpl` 函数用于计算带权路径长度,`huffman_wpl` 函数用于将二者结合起来计算哈夫曼树带权路径长度。最后,在 `main` 函数中,我们定义了一个权值数组,并调用 `huffman_wpl` 函数计算哈夫曼树带权路径长度,然后输出结果。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值