hx=hx-H[i].weight*log10(H[i].weight)/log10(2);//计算信息熵

这段代码应该是在使用结构体表示哈夫曼树节点，计算哈夫曼树的信息熵。其中，`H[i].weight`表示第i个节点的权重，`log10`函数是以10为底数的对数函数，因为计算信息熵时使用的是以2为底数的对数，所以需要将结果用`log10(2)`来除一下。

完整的计算哈夫曼树信息熵的代码可以参考下面的示例：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX_SIZE 100

// 哈夫曼树节点
typedef struct node {
    int weight;
    int parent;
    int lchild;
    int rchild;
} HuffmanNode;

// 哈夫曼编码
typedef struct {
    char ch;
    char code[MAX_SIZE];
} HuffmanCode;

// 计算哈夫曼树的信息熵
double calculate_entropy(HuffmanNode H[], int n) {
    double entropy = 0; // 信息熵
    int i;

    // 计算每个叶子结点的信息熵
    for (i = 0; i < n; i++) {
        if (H[i].lchild == -1 && H[i].rchild == -1) {
            entropy -= H[i].weight * log10(H[i].weight) / log10(2);
        }
    }

    return entropy;
}

int main() {
    int n; // 叶子结点数量
    int i;

    printf("请输入叶子结点数量：");
    scanf("%d", &n);

    // 动态分配哈夫曼树结点数组
    HuffmanNode* H = (HuffmanNode*)malloc(sizeof(HuffmanNode) * (2 * n - 1));

    // 输入每个叶子结点的权重
    printf("请输入每个叶子结点的权重：\n");
    for (i = 0; i < n; i++) {
        printf("w[%d] = ", i);
        scanf("%d", &H[i].weight);
        H[i].lchild = H[i].rchild = H[i].parent = -1;
    }

    // 构造哈夫曼树
    for (i = n; i < 2 * n - 1; i++) {
        int min1, min2; // 两个最小的权重
        int j;

        // 找到权重最小的两个结点
        min1 = min2 = -1;
        for (j = 0; j < i; j++) {
            if (H[j].parent == -1) {
                if (min1 == -1 || H[j].weight < H[min1].weight) {
                    min2 = min1;
                    min1 = j;
                }
                else if (min2 == -1 || H[j].weight < H[min2].weight) {
                    min2 = j;
                }
            }
        }

        // 合并两个最小的权重结点
        H[min1].parent = H[min2].parent = i;
        H[i].lchild = min1;
        H[i].rchild = min2;
        H[i].weight = H[min1].weight + H[min2].weight;
    }

    // 计算哈夫曼树的信息熵
    double entropy = calculate_entropy(H, 2 * n - 1);

    printf("哈夫曼树的信息熵为：%f\n", entropy);

    free(H);
    return 0;
}

这个程序使用了动态分配内存的方法来存储哈夫曼树结点数组，用户输入每个叶子结点的权重后，程序使用最小堆的思想构造哈夫曼树，并计算哈夫曼树的信息熵。