如何递归遍历霍夫曼树以查找特定元素？ - C

Question

I'm working in a Huffman code, and I'm currently at the phase of encoding/decoding the text file into a binary file. I have this piece of code that retrieves a node from the tree along with all its relevant data (character, frecuency, route):

EmptyString ( string );
while ( ( c = fgetc ( nameTextFile ) ) != EOF ) {
    nodeHuffmanTree = SearchHuffmanTree ( rootHuffmanTree, c );
    strcpy ( string, nodeHuffmanTree -> route );
    Encode ( nameBinaryFile, string );
    EmptyString ( string );
}

Assume that the routes for each of these nodes (0's and 1's) have already been generated. What I want of the SearchHuffmanTree function is that, given a character, it searches for said character in the Huffman Tree and it returns me the node that contains it. This is relevant because that node will contain the route that the Encode function will convert into a byte.

I know that i can't treat the Huffman Tree like a Binary Search Tree because it doesn't share the same characteristics, so if I want to search for an specific character I'll have to traverse the whole tree.

I've already looked for alternatives without using recursion (and a stack in some) and, althought they are easier to understand, they produce considerably less simple and clean looking codes, so I'd prefer solutions using recursion.

I've already figured out the encoding/decoding part, so this is pretty much the final step towards finally finishing up my code. Looking forward to any help you can give me.

Answer 1

Yes, you cannot assume anything about the position of any specific node (ie character) in your tree, since the position of the nodes depends on the frequency of the characters and not on their values. Thus, you will have to find a way to traverse the whole tree, without making any assumptions.

There are 2 ways of traversing a graph in general: breadth first search (BFS), which is based on a queue, and depth first search (DFS), which is based on a stack.

Since the DFS is based on a stack, it is an inherently recursive problem. Also, due to the differences in the way the 2 approaches traverse the tree, DFS will be more efficient on average in your case.

How does DFS work?

Well, the basic principle is that if a node is not a leaf, perform a DFS on each of its children. If you choose the order in which the subtrees are traversed, you can take the highest probability path first, which increases your chances of finding the result faster.

Below is a simple pseudocode of the algorithm:

DFS(node T, char x) {
    if (T is leaf)
        if (T == x)
            return found
        else
            return not found
    else
        foreach child of T
            if DFS(child, x) == found
                return found
        return not found

You can find more details on the Wikipedia page of DFS .