Outline

• Huffman coding
• Huffman trees
• implementation
• java types, classes, and interfaces

Huffman coding

• suppose you wanted to compress a text file, that is, represent it using the least possible number of bits
• suppose also you want to use a unique string of bits for each character -- that is, we are not going to encode entire words
• it would be good to use fewer bits for characters that occur frequently, and as many bits as needed for other characters
• for example, in the string "hello world", I could use the following encoding:

  letter	bit string
  h	11000
  e	11001
  l	0
  o	10
  ' ' (space)	11010
  w	11011
  r	1110
  d	1111

• in-class exercise: what does the bit string (25 bits) "1100 0100 1101 0111 1101 0111 0" represent?
• note that the above string takes 45 bits if each character is represented with a constant 5 bits/character, which is the smallest number of bits to represent all 26 characters and space
• so Huffman coding can save space!
• it does this by using shorter bit strings to encode more commonly-used characters, and longer bit strings to encode less frequently used characters

algorithm for building a Huffman coding tree

1. make a list of all symbols with their frequencies
2. sort the list so the symbols with the least frequency are in front
3. if the list only has one element, the element is the root of the tree and we are done
4. remove the first two elements from the list and put them into a binary tree
5. add the frequencies of the two subtrees to give the frequency of this binary tree
6. insert this tree in the right place in the sorted list
7. return to step 3

• in-class exercise: do this for the characters in "hello world"

  letter	frequency
  h	1
  e	1
  l	3
  o	2
  ' ' (space)	1
  w	1
  r	1
  d	1

using a Huffman coding tree

• to encode:
  • find the leaf with the next character to encode
  • starting from the root to this leaf, place a 0 bit for each time you take the left subtree, and a 1 bit for each time you take the right subtree
• in-class exercise: use this algorithm and the tree from the last exercise to encode the string "wow"
• can do the above search once for each character, put the results in a table (e.g. a hash table), then use the table to do the actual encoding quickly
• to decode:
  • use each bit to go left (0 bit) or right (1 bit) in the tree
  • if you have reached a leaf, put this character into the result string, then
  • start at the root of the tree with the next bit
• in-class exercise: use this algorithm and the above tree to decode as many bits as possible of the bit string "1100 0100 1101 0111 1101 0111 0"

compression using Huffman coding

• an encoding based on letter frequencies in one string (or a large sample) can be used for encoding many different strings
• if so, a single copy of the table (tree) can be kept, and huffman coding is guaranteed to do no worse than fixed-length encoding
• otherwise, a separate table (tree) is needed for each compression, and the table has to be included in the count of bytes to be stored or transmitted after compression
• in such cases, Huffman coding might actually give a somewhat larger size than the original
• in practice, even including the table, Huffman coding is usually worthwhile for sufficiently long strings in natural languages, which have lots of redundancy and different letter frequencies

an implementation for Huffman trees

• many possible implementations, this is one (textbook, chapter 8.6)
• use several data structures:
  • a priority queue implemented by a min heap to hold the sorted data
  • each heap element refers to a tree node
  • an interior tree node has no value, but has two children
  • a leaf node has a value, but has no children
  • each node has a frequency of occurrence, which is used as a priority in the queue (low priority returned first)
• begin by computing the frequency of each value, perhaps by using a hash table (can use a perfect hash if the number of values is known in advance, e.g. 128 or 65,536 characters)
• once the frequency of values is known, insert each value into the priority queue, using its frequency as a priority
• remove the front two elements from the queue, create an interior node to refer to these two elements, and insert the interior node back into the queue with, as priority, the sum of the priorities of the two nodes
• once there is only one element left in the queue, this is the huffman tree
• a further step would be to build an encoding table from the tree
• in-class exercise: do this given the string "there is no place like home"

Java types, classes, and interfaces

• every variable in Java has a type
• a type is one of the 8 basic types (char, boolean, byte, short, int, long, float, double), or an object type
• a variable of a basic types can never be null, whereas any variable of an object type may be null
• == is used to compare variables of basic types, to compare object types to null, and to find out if two references refer to the same object
• object types are defined by either a class or an interface declaration
• the declaration determines which operations are available for a variable, for example, given:

  Object x = new String("hello world");
  

  the expression

    char c = x.charAt(0);
  

  is not legal in Java, because an Object does not have a charAt method, and x is an object, not a string
• the underlying object that x refers to was created as a string, but Java does not keep track of this. The compiler only remembers that x is an Object
• when a method is called, e.g.

    int i = x.hashCode();
  

  the corresponding method from the String class is invoked