分配二叉树值（霍夫曼编码）

Question

目的是读取文件，计算每个字符的频率并执行霍夫曼编码，其中最常见的字母将是短二进制代码，即 001，而最不常见的字母会更长，即 01000100。

我创建了一个链接列表，其中包含所有字符及其各自频率的排序（按升序）列表。这被传递给下面的函数。在这个函数中，我的目标是添加两个最低频率并像这样构建二叉树，直到树的长度为 1。我不确定从这里去哪里，我知道我必须查看树并查看哪个将它向左或向右移动，然后存储 0（左）或 1（右）。 - 但我不知道如何构建一个函数来做到这一点！

void traverse_list(pqueue *list)
    {
    char letters[CHARACTERS] = { 0 };
    int frequencies[CHARACTERS] = { 0 };
    int j = 0, l = 0, len = 0;
    node *temp = list->head;
    tree *array[CHARACTERS];
    while (temp != NULL)
    {
        letters[j] = temp->letter;
        frequencies[j] = temp -> frequency;
        temp = temp->next;
        j++;
    }
    for (l = 0; l < CHARACTERS; l++)
    {
        if (frequencies[j])
        {
            tree* huffman = calloc(1, sizeof(tree));
            huffman -> letter = letters[l];
            huffman -> frequency = frequencies[l];
            array[len++] = huffman;
        }
    }

    while (len > 1)
    {
        tree* huffman = malloc(sizeof(tree));
        huffman -> left = array[len--];
        huffman -> right = array[len--];
        huffman -> frequency = huffman -> left -> frequency + huffman -> right -> frequency;
        array[len++] = huffman;
    } 
}

为了便于阅读，结构如下所示：

typedef struct Node
{
    char letter;
    int frequency;
    struct Node *next;

}node;

typedef struct pqueue
{
    node *head;

}pqueue;

typedef struct tree
{
    struct tree *left;
    struct tree *right;
    char letter;
    int frequency;
}tree;

Answer 1

我不明白你为什么要创建这么多数组，然后再次使用它们创建新节点。我认为这可以通过修改Node 的结构来轻松完成。像这样的东西::

typedef struct Node
{
    char letter;
    int frequency;
    struct Node *next;
    struct Node *left, *right;
}node;

因此，您可以执行以下操作来形成一棵树。

void huffman(plist *list) {
    while(1) {
        node *left = list->head;
        list->head = list->head->next;
        node *right = list->head;
        list->head = list->head->next;

        node *huffman = malloc(sizeof(node));
        huffman->frequency = left->frequency;
        huffman->left = left;
        huffman->right = right;
        huffman->next = NULL;

        if(list->head == NULL) {
            list->head = huffman;
            break;
        }
        insertHuffman(root, huffman);
    }
}

您的insertHuffman() 将在pList 中按排序顺序插入新的node。所以，最后你在树中只剩下一个node，然后你可以简单地进行一次遍历来决定每个节点的值。您绝对可以选择比我使用的while(1) 更好的条件！ :P 我使用它是因为这是我想到的第一件事。我相信你肯定可以写insertHuffman()。

编辑::

void printHuffman(node *head, node *parent, char *a, int len) {
    if(head->left == NULL && head->right == NULL) {
        if(parent != NULL && parent->right == head) {
            cout << head->letter << " " << a << "1";
        } else if(parent != NULL && parent->left == head) {
            cout << head->letter << " " << a;
        }
    } else {
        a[len] = '0';
        printHuffman(head->left, head, a, len + 1);
        a[len] = '1';
        printHuffman(head->right, head, a, len + 1);
    }
}

我认为这将打印每个字符的霍夫曼值。

这里，a 是大小为CHARACTERS 的字符数组，所有初始化为\0 和len 的值都保存当前代码的值。

编辑 2 ::

我已经看到您尝试将字符 tree 节点组合成 1 个 tree 节点的方式，方法是从升序排序数组中取出最后两个节点，并将它们组合成一个新节点，该节点位于结束数组。根据我对霍夫曼编码的了解，您不会将具有最大频率的元素组合在一起，而是将具有最低频率的元素组合在一起，然后形成用于查找霍夫曼编码的树。

Answer 2

尝试改变

        huffman -> left = array[len--];
        huffman -> right = array[len--];

到

        huffman -> left = array[--len];
        huffman -> right = array[--len];

为了得到数组的最后一个元素。