Question

The following problem was done using Java.

Question: Design, code, and test a program that implements an optimal Huffman algorithm with a time complexity of O(n log2n), n being the number of code symbols).

My code keeps giving me errors. Please post code and solution.

Answer 1

CODE

import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Comparator;

// node class is the basic structure
// of each node present in the Huffman - tree.
class HuffmanNode {

   int data;
   char c;

   HuffmanNode left;
   HuffmanNode right;
}

// comparator class helps to compare the node
// on the basis of one of its attribute.
// Here we will be compared
// on the basis of data values of the nodes.
class MyComparator implements Comparator<HuffmanNode> {
   public int compare(HuffmanNode x, HuffmanNode y)
   {
       return x.data - y.data;
   }
}

public class Huffman {

   // recursive function to print the
   // huffman-code through the tree traversal.
   // Here s is the huffman - code generated.
   public static void printCode(HuffmanNode root, String s)
   {

       // base case; if the left and right are null
       // then its a leaf node and we print
       // the code s generated by traversing the tree.
       if (root.left == null && root.right == null && Character.isLetter(root.c)) {
// c is the character in the node
           System.out.println(root.c + ":" + s);

           return;
       }

       // if we go to left then add "0" to the code.
       // if we go to the right add"1" to the code.

       // recursive calls for left and
       // right sub-tree of the generated tree.
       printCode(root.left, s + "0");
       printCode(root.right, s + "1");
   }

   // main function
   public static void main(String[] args)
   {

       Scanner s = new Scanner(System.in);

       // number of characters.
       int n = 6;
       char[] charArray = { 'a', 'b', 'c', 'd', 'e', 'f' };
       int[] charfreq = { 5, 9, 12, 13, 16, 45 };

       // creating a priority queue q.
       // makes a min-priority queue(min-heap).
       PriorityQueue<HuffmanNode> q = new PriorityQueue<HuffmanNode>(n, new MyComparator());

       for (int i = 0; i < n; i++) {

           // creating a Huffman node object
           // and add it to the priority queue.
           HuffmanNode hn = new HuffmanNode();

           hn.c = charArray[i];
           hn.data = charfreq[i];

           hn.left = null;
           hn.right = null;

           // add functions adds
           // the huffman node to the queue.
           q.add(hn);
       }

       // create a root node
       HuffmanNode root = null;

       // Here we will extract the two minimum value
       // from the heap each time until
       // its size reduces to 1, extract until
       // all the nodes are extracted.
       while (q.size() > 1) {

           // first min extract.
           HuffmanNode x = q.peek();
           q.poll();

           // second min extarct.
           HuffmanNode y = q.peek();
           q.poll();

           // new node f which is equal
           HuffmanNode f = new HuffmanNode();

           // to the sum of the frequency of the two nodes
           // assigning values to the f node.
           f.data = x.data + y.data;
           f.c = '-';

           // first extracted node as left child.
           f.left = x;

           // second extracted node as the right child.
           f.right = y;

           // marking the f node as the root node.
           root = f;

           // add this node to the priority-queue.
           q.add(f);
       }

       // print the codes by traversing the tree
       printCode(root, "");
   }
}

OUTPUT

Time complexity:
O(nlogn) where n is the number of unique characters.
If there are n nodes, extractMin() is called 2*(n – 1) times. extractMin() takes O(logn) time as it calles minHeapify().
So, overall complexity is O(nlogn).