# Huffman Coding

https://www.geeksforgeeks.org/huffman-coding-greedy-algo-3/

``````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 adding it to the priority-queue.
HuffmanNode hn = new HuffmanNode();

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

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

// the huffman node to the queue.
}

// 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.