A Quick Tutorial on Generating a Huffman Tree

Let's say you have a set of numbers, sorted by their frequency of use, and you want to create a huffman encoding for them:

ValueFrequency
15
27
310
415
520
645

Creating a huffman tree is simple. Sort this list by frequency and make the two-lowest elements into leaves, creating a parent node with a frequency that is the sum of the two lower element's frequencies:

        12:*
        /  \
      5:1   7:2

The two elements are removed from the list and the new parent node, with frequency 12, is inserted into the list by frequency. So now the list, sorted by frequency, is:

ValueFrequency
310
*12
415
520
645

You then repeat the loop, combining the two lowest elements. This results in:

    22:*
    /   \
 10:3   12:*
        /   \
      5:1   7:2

and the list is now:

ValueFrequency
415
520
*22
645

You repeat until there is only one element left in the list.

    22:*           35:*
    /   \          /   \
 10:3   12:*     15:4  20:5
        /   \
      5:1   7:2
ValueFrequency
*22
*35
645
            57:*
        ___/    \___
       /            \
     22:*          35:*
    /   \          /   \
 10:3   12:*     15:4   20:5
        /   \
      5:1   7:2
ValueFrequency
645
*57

                                   102:*
                __________________/    \__
               /                          \
            57:*                         45:6
        ___/    \___
       /            \
     22:*          35:*
    /   \          /   \
 10:3   12:*     15:4   20:5
        /   \
      5:1   7:2

Now the list is just one element containing 102:*, and you are done.

This element becomes the root of your binary huffman tree. To generate a huffman code you traverse the tree for each value you want to encode, outputting a0 every time you take a left-hand branch, and a1 every time you take a right-hand branch (normally you traverse the tree backwards from the code you want and build the binary huffman encoding string backwards as well, since thefirst bit must start from the top).

Example: The encoding for the value4 (15:4) is010. The encoding for the value6 (45:6) is1.

Decoding a huffman encoding is just as easy: as you read bits in from your input stream you traverse the tree beginning at the root, taking the left hand path if you read a0 and the right hand path if you read a1. When you hit a leaf, you have found the code.

Generally, any huffman compression scheme also requires the huffman tree to be written out as part of the file, otherwise the reader cannot decode the data. For a static tree, you don't have to do this since the tree is known and fixed.

The easiest way to output the huffman tree itself is to, starting at the root, dump first the left hand side then the right hand side. For each node you output a0, for each leaf you output a1 followed by N bits representing the value. For example, the partial tree in my last example above using 4 bits per value can be represented as follows:

  000100 fixed 6 bit byte indicates how many bits the value
         for each leaf is stored in.  In this case, 4.
  0      root is a node
         left hand side is
  10011  a leaf with value 3
         right hand side is
  0      another node
         recurse down, left hand side is
  10001  a leaf with value 1
         right hand side is
  10010  a leaf with value 2
         recursion return

So the partial tree can be represented with00010001001101000110010, or 23 bits. Not bad!