建立一个huffman树，给定6个结点的数值分别为a:3、b:2、c:1、d:5、e:6、f:4。画出huffman树

抱歉，我可以回答您的问题。以下是根据您提供的数值绘制的Huffman树：

21
/ \
/ \
9 12
/ \ / \
c b a f
/ \
d e

相关问题

2)初始化一个数据元素为数值型的序列，将其作为叶子结点构造哈夫曼树并对其进行编码。示例：给定序列529781423311返回每个数据元素的哈夫曼编码，如下图所示。实现思路及步骤(注意：使用变量不要忘记添加变量的声明)：A、类型定义哈夫曼树的存储结构；p147B、基本操作1)在序列中权值最小的两个结点，赋值给s1，s2；voidSelect(HuffmanTree&HT,intx)1、循环x个结点，对比其weght值是否为最小且parent为0，将其设为min1并赋值给s1；

好的，我明白了。针对你的问题，我可以给出以下实现思路及步骤：

A、首先，我们需要定义哈夫曼树的存储结构。可以使用以下结构体表示哈夫曼树的结点：

typedef struct HTNode {
    int weight; // 权值
    int parent; // 父结点
    int lchild; // 左孩子结点
    int rchild; // 右孩子结点
} HuffmanTree[MAX_SIZE * 2 - 1];

其中，`MAX_SIZE` 表示序列的最大长度，哈夫曼树的结点数为 `MAX_SIZE * 2 - 1`。

B、接下来，我们需要实现基本操作，包括：

1）在序列中选取权值最小的两个结点，赋值给 `s1` 和 `s2`。

void Select(HuffmanTree &HT, int x, int &s1, int &s2) {
    int i;
    int min1 = INT_MAX, min2 = INT_MAX;
    for (i = 1; i <= x; i++) {
        if (HT[i].weight < min1 && HT[i].parent == 0) {
            min2 = min1;
            s2 = s1;
            min1 = HT[i].weight;
            s1 = i;
        }
        else if (HT[i].weight < min2 && HT[i].parent == 0) {
            min2 = HT[i].weight;
            s2 = i;
        }
    }
}

其中，`x` 表示当前哈夫曼树的结点数，`s1` 和 `s2` 分别表示选取的两个权值最小的结点的下标。

2）创建哈夫曼树。

void CreateHuffmanTree(HuffmanTree &HT, int n) {
    int i, s1, s2;
    for (i = 1; i <= n; i++) {
        HT[i].weight = // 序列中第 i 个元素的权值
        HT[i].parent = 0;
        HT[i].lchild = 0;
        HT[i].rchild = 0;
    }
    for (i = n + 1; i <= 2 * n - 1; i++) {
        HT[i].weight = 0;
        HT[i].parent = 0;
        HT[i].lchild = 0;
        HT[i].rchild = 0;
    }
    for (i = n + 1; i <= 2 * n - 1; i++) {
        Select(HT, i - 1, s1, s2);
        HT[s1].parent = i;
        HT[s2].parent = i;
        HT[i].lchild = s1;
        HT[i].rchild = s2;
        HT[i].weight = HT[s1].weight + HT[s2].weight;
    }
}

其中，`n` 表示序列的长度，`HT` 表示哈夫曼树的存储结构。

C、最后，我们需要对每个数据元素进行编码。

void HuffmanEncoding(HuffmanTree &HT, int n, string *HC) {
    int i, j, k;
    char *cd = new char[n];
    cd[n - 1] = '\0';
    for (i = 1; i <= n; i++) {
        int start = n - 1;
        for (j = i, k = HT[i].parent; k != 0; j = k, k = HT[k].parent) {
            if (HT[k].lchild == j) {
                cd[--start] = '0';
            }
            else {
                cd[--start] = '1';
            }
        }
        HC[i] = cd + start;
    }
    delete[] cd;
}

其中，`n` 表示序列的长度，`HT` 表示哈夫曼树的存储结构，`HC` 表示每个数据元素的哈夫曼编码。

希望我的回答能够帮助到你，如果还有问题，请随时提出。

初始化一个数据元素为数值型的序列，将其作为叶子结点构造哈夫曼树并对其进行编码。示例： 给定序列 5 29 7 8 14 23 3 11使用c语言表示

好的，下面是使用 C 语言表示初始化一个数据元素为数值型的序列、构造哈夫曼树并对其进行编码的代码：

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

#define MAX_SIZE 100

typedef struct {
    int weight;
    int parent, left, right;
} HTNode, *HuffmanTree;

typedef char *HuffmanCode[MAX_SIZE];

void HuffmanCoding(HuffmanTree *HT, HuffmanCode *HC, int *w, int n) {
    int i, j, start, c, f;
    HuffmanTree p;
    char *cd;
    int m = 2 * n - 1;

    *HT = (HuffmanTree)malloc((m + 1) * sizeof(HTNode));
    *HC = (HuffmanCode)malloc((n + 1) * sizeof(char *));

    for (i = 1; i <= n; i++) {
        (*HT)[i].weight = w[i - 1];
        (*HT)[i].parent = 0;
        (*HT)[i].left = 0;
        (*HT)[i].right = 0;
    }

    for (; i <= m; i++) {
        (*HT)[i].weight = 0;
        (*HT)[i].parent = 0;
        (*HT)[i].left = 0;
        (*HT)[i].right = 0;
    }

    for (i = n + 1; i <= m; i++) {
        int s1 = 0, s2 = 0;
        for (j = 1; j < i; j++) {
            if ((*HT)[j].parent == 0) {
                if ((*HT)[j].weight < (*HT)[s1].weight) {
                    s2 = s1;
                    s1 = j;
                } else if ((*HT)[j].weight < (*HT)[s2].weight) {
                    s2 = j;
                }
            }
        }
        (*HT)[s1].parent = i;
        (*HT)[s2].parent = i;
        (*HT)[i].left = s1;
        (*HT)[i].right = s2;
        (*HT)[i].weight = (*HT)[s1].weight + (*HT)[s2].weight;
    }

    *HC = (HuffmanCode)malloc((n + 1) * sizeof(char *));
    cd = (char *)malloc(n * sizeof(char));
    cd[n - 1] = '\0';
    for (i = 1; i <= n; i++) {
        start = n - 1;
        for (c = i, f = (*HT)[i].parent; f != 0; c = f, f = (*HT)[f].parent) {
            if ((*HT)[f].left == c) {
                cd[--start] = '0';
            } else {
                cd[--start] = '1';
            }
        }
        (*HC)[i] = (char *)malloc((n - start) * sizeof(char));
        strcpy((*HC)[i], &cd[start]);
    }
    free(cd);
}

int main() {
    int w[] = {5, 29, 7, 8, 14, 23, 3, 11};
    int n = sizeof(w) / sizeof(w[0]);

    HuffmanTree HT;
    HuffmanCode HC;

    HuffmanCoding(&HT, &HC, w, n);

    printf("Huffman codes:\n");
    for (int i = 1; i <= n; i++) {
        printf("%d: %s\n", w[i - 1], HC[i]);
    }

    return 0;
}

希望能够解答您的疑问。