二叉树在构建树时丢失节点

Question

I have built a binary tree (huffman tree) using the code below which takes a sorted in ascending order linked list, however when it finishes running it prints the bit-patterns and a few of the nodes that should be in the tree aren't.

The code essentially:

1. sets parent node to point at two lowest nodes

2. assigns internal frequency of parent node

3. points the start of the list to now be at nodes 2 along from where it was (to avoid re-using nodes)

4. inserts the new parent node into the correct position in the tree

5. gets the length of the tree

6. print all nodes left in list

7. iterates until one node is left (which is the root).

Any ideas as to why its 'losing' nodes along the way?

void build_tree(pqueue *list)
{

    node *temp; 
    node* parent_node;
    int min_1, min_2, ind = 0, counter = 0, length = 2, head;
    int characters[CHARACTERS];
    temp = new_node();

    while (length > 1)
    {
        min_1 = 0;
        min_2 = 0;
        temp = list->start;           
        parent_node = new_node(); 
        parent_node->letter = '#';             
        min_1 = temp->frequency;
        parent_node->left = temp;         
        temp = temp->next;               
        min_2 = temp->frequency;
        parent_node->right = temp;       
        parent_node->frequency = min_1 + min_2;
        list->start = temp->next;

        while (ind == 0) /* inserting a node to the correct place */
        {
            if (temp != NULL && temp->next != NULL)
            {
                temp = temp->next;
                if (temp->frequency >= parent_node->frequency) /* in the middle */
                {
                    parent_node->next = temp->next;
                    temp->next = parent_node;
                    ind = 1;
                }
                else if (temp->next == NULL) /* at the end */
                {
                    temp->next = parent_node;
                    parent_node -> next = NULL;
                    ind = 1;
                }
            }
        }
        ind = 0;
        temp =  list->start;
        while (temp->next != NULL) /* get number of nodes left to insert into tree */
        {
            temp = temp->next;
            counter++;
            printf("%c : %d\n", temp->letter, temp->frequency); 
        }
        printf("----------------------------------------------\n");
        length = counter;
        counter = 0;
    }
    printf("Found root with value of: %d\n", temp->frequency);
    head = 0;
    BitPatterns(temp, characters, head);
    temp = list->start;
    deallocate(temp, list);
}


void BitPatterns(node* root, int characters[], int head)
{
    if (root->left)
    {
        characters[head] = 0;
        BitPatterns(root->left, characters, head +1);
    }

    if (root->right)
    {
        characters[head] = 1;
        BitPatterns(root->right, characters, head +1);
    }


    if (isLeaf(root))
    {
        printf("'%c' : ", root->letter);
        GetChars(characters, head);

    }
}

void GetChars(int characters[], int n)
{
    int i, counter = 0;
    for (i = 0; i < n; ++i)
    {
        printf("%d", characters[i]);
        counter++;

    }
    printf(" (%d * \n", counter);

}

int isLeaf(node* root)
{
    return !(root->left) && !(root->right) ;
}

Answer 1

Ok! It was a tough one to debug. But, I think I have found the problem. The problem is with the while loop, where you find the length of the list, that is left for processing. Since the condition in the while loop is temp->next != NULL , so, consider that your List is of size 2, something like this ::

3 --> 4 --> NULL (Numbers represent the sum of frequencies of some nodes)

With list->start pointing to 3. And you will measure the length of this list to 1 and not 2, because you are checking temp->next != NULL .

Because of this you miss a crucial second node of the list, and you run BitPatterns() only on the first node, and you miss a few nodes.

A possible solution to this would be to insert a while loop at the beginning of the function to measure the length for once, and that could be decremented by 1 in every consecutive iteration of the while loop, where you combine two nodes, since you are removing two nodes and adding one node to the list always, you only have to decrement the length by 1. This would also save a lot of extra computation that you do at the end of the list for computing the length of the list everytime.

Something like this ::

temp = list->start;
while(temp != NULL) {
    length++;
    temp = temp->next;
}

EDIT :: Moreover, there's another logical bug that I see in your code ::

Consider that the initial list is this ::

1 --> 2 --> 4 --> 5 --> NULL

You combine the first two nodes, let that node be called A (with freq = 3) for the moment and list_start points to 4 . So, when you insert the node in the list looks something like this ::

4 --> A --> 5 --> NULL

Though the list, shall look something like this ::

A --> 4 --> 5

This, does not affect the functioning of the code, but might lead to some un-optimized huffman code results.