GeeksforGeeks App
Open App
Browser
Continue

# Huffman Coding using Priority Queue

Prerequisite: Greedy Algorithms | Set 3 (Huffman Coding), priority_queue::push() and priority_queue::pop() in C++ STL
Given a char array ch[] and frequency of each character as freq[]. The task is to find Huffman Codes for every character in ch[] using Priority Queue.

Example

Input: ch[] = { ‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’ }, freq[] = { 5, 9, 12, 13, 16, 45 }
Output:
f 0
c 100
d 101
a 1100
b 1101
e 111

Approach:

1. Push all the characters in ch[] mapped to corresponding frequency freq[] in priority queue.
2. To create Huffman Tree, pop two nodes from priority queue.
3. Assign two popped node from priority queue as left and right child of new node.
4. Push the new node formed in priority queue.
5. Repeat all above steps until size of priority queue becomes 1.
6. Traverse the Huffman Tree (whose root is the only node left in the priority queue) to store the Huffman Code
7. Print all the stored Huffman Code for every character in ch[].

Below is the implementation of the above approach:

## C++

 `// C++ Program for Huffman Coding``// using Priority Queue``#include ``#include ``using` `namespace` `std;` `// Maximum Height of Huffman Tree.``#define MAX_SIZE 100` `class` `HuffmanTreeNode {``public``:``    ``// Stores character``    ``char` `data;` `    ``// Stores frequency of``    ``// the character``    ``int` `freq;` `    ``// Left child of the``    ``// current node``    ``HuffmanTreeNode* left;` `    ``// Right child of the``    ``// current node``    ``HuffmanTreeNode* right;` `    ``// Initializing the``    ``// current node``    ``HuffmanTreeNode(``char` `character,``                    ``int` `frequency)``    ``{``        ``data = character;``        ``freq = frequency;``        ``left = right = NULL;``    ``}``};` `// Custom comparator class``class` `Compare {``public``:``    ``bool` `operator()(HuffmanTreeNode* a,``                    ``HuffmanTreeNode* b)``    ``{``        ``// Defining priority on``        ``// the basis of frequency``        ``return` `a->freq > b->freq;``    ``}``};` `// Function to generate Huffman``// Encoding Tree``HuffmanTreeNode* generateTree(priority_queue,``                                             ``Compare> pq)``{` `    ``// We keep on looping till``    ``// only one node remains in``    ``// the Priority Queue``    ``while` `(pq.size() != 1) {` `        ``// Node which has least``        ``// frequency``        ``HuffmanTreeNode* left = pq.top();` `        ``// Remove node from``        ``// Priority Queue``        ``pq.pop();` `        ``// Node which has least``        ``// frequency``        ``HuffmanTreeNode* right = pq.top();` `        ``// Remove node from``        ``// Priority Queue``        ``pq.pop();` `        ``// A new node is formed``        ``// with frequency left->freq``        ``// + right->freq` `        ``// We take data as '\$'``        ``// because we are only``        ``// concerned with the``        ``// frequency``        ``HuffmanTreeNode* node = ``new` `HuffmanTreeNode(``'\$'``,``                                  ``left->freq + right->freq);``        ``node->left = left;``        ``node->right = right;` `        ``// Push back node``        ``// created to the``        ``// Priority Queue``        ``pq.push(node);``    ``}` `    ``return` `pq.top();``}` `// Function to print the``// huffman code for each``// character.` `// It uses arr to store the codes``void` `printCodes(HuffmanTreeNode* root,``                ``int` `arr[], ``int` `top)``{``    ``// Assign 0 to the left node``    ``// and recur``    ``if` `(root->left) {``        ``arr[top] = 0;``        ``printCodes(root->left,``                   ``arr, top + 1);``    ``}` `    ``// Assign 1 to the right``    ``// node and recur``    ``if` `(root->right) {``        ``arr[top] = 1;``        ``printCodes(root->right, arr, top + 1);``    ``}` `    ``// If this is a leaf node,``    ``// then we print root->data` `    ``// We also print the code``    ``// for this character from arr``    ``if` `(!root->left && !root->right) {``        ``cout << root->data << ``" "``;``        ``for` `(``int` `i = 0; i < top; i++) {``            ``cout << arr[i];``        ``}``        ``cout << endl;``    ``}``}` `void` `HuffmanCodes(``char` `data[],``                  ``int` `freq[], ``int` `size)``{` `    ``// Declaring priority queue``    ``// using custom comparator``    ``priority_queue,``                   ``Compare>``        ``pq;` `    ``// Populating the priority``    ``// queue``    ``for` `(``int` `i = 0; i < size; i++) {``        ``HuffmanTreeNode* newNode``            ``= ``new` `HuffmanTreeNode(data[i], freq[i]);``        ``pq.push(newNode);``    ``}` `    ``// Generate Huffman Encoding``    ``// Tree and get the root node``    ``HuffmanTreeNode* root = generateTree(pq);` `    ``// Print Huffman Codes``    ``int` `arr[MAX_SIZE], top = 0;``    ``printCodes(root, arr, top);``}` `// Driver Code``int` `main()``{``    ``char` `data[] = { ``'a'``, ``'b'``, ``'c'``, ``'d'``, ``'e'``, ``'f'` `};``    ``int` `freq[] = { 5, 9, 12, 13, 16, 45 };``    ``int` `size = ``sizeof``(data) / ``sizeof``(data[0]);` `    ``HuffmanCodes(data, freq, size);``    ``return` `0;``}`

## Java

 `import` `java.util.*;` `class` `HuffmanTreeNode``    ``implements` `Comparable``    ``{``    ` `    ``// Stores character``    ``char` `data;``    ` `    ``// Stores frequency of the character``    ``int` `freq;``    ` `    ``// Left child of the current node``    ``HuffmanTreeNode left;``    ` `    ``// Right child of the current node``    ``HuffmanTreeNode right;` `    ``public` `HuffmanTreeNode(``char` `character, ``int` `frequency)``    ``{``        ``data = character;``        ``freq = frequency;``        ``left = right = ``null``;``    ``}` `    ``public` `int` `compareTo(HuffmanTreeNode other)``    ``{``        ``return` `freq - other.freq;``    ``}``}` `class` `HuffmanCodes {` `    ``// Maximum Height of Huffman Tree.``    ``static` `final` `int` `MAX_SIZE = ``100``;` `    ``// Function to print the huffman code for each``    ``// character. It uses arr to store the codes``    ``static` `void` `printCodes(HuffmanTreeNode root, ``int``[] arr,``                           ``int` `top)``    ``{``        ``// Assign 0 to the left node and recur``        ``if` `(root.left != ``null``) {``            ``arr[top] = ``0``;``            ``printCodes(root.left, arr, top + ``1``);``        ``}` `        ``// Assign 1 to the right node and recur``        ``if` `(root.right != ``null``) {``            ``arr[top] = ``1``;``            ``printCodes(root.right, arr, top + ``1``);``        ``}` `        ``// If this is a leaf node, then we print root.data``        ``// We also print the code for this character from``        ``// arr``        ``if` `(root.left == ``null` `&& root.right == ``null``) {``            ``System.out.print(root.data + ``" "``);``            ``for` `(``int` `i = ``0``; i < top; ++i) {``                ``System.out.print(arr[i]);``            ``}``            ``System.out.println();``        ``}``    ``}` `    ``// Function to generate Huffman Encoding Tree``    ``static` `HuffmanTreeNode``    ``generateTree(PriorityQueue pq)``    ``{``    ` `        ``// We keep on looping till only one node remains in``        ``// the Priority Queue``        ``while` `(pq.size() != ``1``) {``        ` `            ``// Node which has least frequency``            ``HuffmanTreeNode left = pq.poll();` `            ``// Node which has least frequency``            ``HuffmanTreeNode right = pq.poll();` `            ``// A new node is formed with frequency left.freq``            ``// + right.freq We take data as '\$' because we``            ``// are only concerned with the frequency``            ``HuffmanTreeNode node = ``new` `HuffmanTreeNode(``                ``'\$'``, left.freq + right.freq);``            ``node.left = left;``            ``node.right = right;` `            ``// Push back node created to the Priority Queue``            ``pq.add(node);``        ``}` `        ``return` `pq.poll();``    ``}` `    ``// Function to generate Huffman Codes``    ``static` `void` `HuffmanCodes(``char``[] data, ``int``[] freq,``                             ``int` `size)``    ``{``        ``// Declaring priority queue using custom comparator``        ``PriorityQueue pq``            ``= ``new` `PriorityQueue<>();` `        ``// Populating the priority queue``        ``for` `(``int` `i = ``0``; i < size; i++) {``            ``HuffmanTreeNode newNode``                ``= ``new` `HuffmanTreeNode(data[i], freq[i]);``            ``pq.add(newNode);``        ``}` `        ``// Generate Huffman Encoding Tree and get the root``        ``// node``        ``HuffmanTreeNode root = generateTree(pq);` `        ``// Print Huffman Codes``        ``int``[] arr = ``new` `int``[MAX_SIZE];``        ``int` `top = ``0``;``        ``printCodes(root, arr, top);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``char``[] data = { ``'a'``, ``'b'``, ``'c'``, ``'d'``, ``'e'``, ``'f'` `};``        ``int``[] freq = { ``5``, ``9``, ``12``, ``13``, ``16``, ``45` `};``        ``int` `size = data.length;` `        ``// Function call``        ``HuffmanCodes(data, freq, size);``    ``}``}`

## Python3

 `import` `queue` `# Maximum Height of Huffman Tree.``MAX_SIZE ``=` `100` `class` `HuffmanTreeNode:``    ``def` `__init__(``self``, character, frequency):``        ``# Stores character``        ``self``.data ``=` `character` `        ``# Stores frequency of the character``        ``self``.freq ``=` `frequency` `        ``# Left child of the current node``        ``self``.left ``=` `None` `        ``# Right child of the current node``        ``self``.right ``=` `None``    ` `    ``def` `__lt__(``self``, other):``        ``return` `self``.freq < other.freq` `# Custom comparator class``class` `Compare:``    ``def` `__call__(``self``, a, b):``        ``# Defining priority on the basis of frequency``        ``return` `a.freq > b.freq` `# Function to generate Huffman Encoding Tree``def` `generateTree(pq):``    ``# We keep on looping till only one node remains in the Priority Queue``    ``while` `pq.qsize() !``=` `1``:``        ``# Node which has least frequency``        ``left ``=` `pq.get()` `        ``# Node which has least frequency``        ``right ``=` `pq.get()` `        ``# A new node is formed with frequency left.freq + right.freq``        ``# We take data as '\$' because we are only concerned with the frequency``        ``node ``=` `HuffmanTreeNode(``'\$'``, left.freq ``+` `right.freq)``        ``node.left ``=` `left``        ``node.right ``=` `right` `        ``# Push back node created to the Priority Queue``        ``pq.put(node)` `    ``return` `pq.get()` `# Function to print the huffman code for each character.``# It uses arr to store the codes``def` `printCodes(root, arr, top):``    ``# Assign 0 to the left node and recur``    ``if` `root.left:``        ``arr[top] ``=` `0``        ``printCodes(root.left, arr, top ``+` `1``)` `    ``# Assign 1 to the right node and recur``    ``if` `root.right:``        ``arr[top] ``=` `1``        ``printCodes(root.right, arr, top ``+` `1``)` `    ``# If this is a leaf node, then we print root.data``    ``# We also print the code for this character from arr``    ``if` `not` `root.left ``and` `not` `root.right:``        ``print``(root.data, end``=``' '``)``        ``for` `i ``in` `range``(top):``            ``print``(arr[i], end``=``'')``        ``print``()` `def` `HuffmanCodes(data, freq, size):``    ``# Declaring priority queue using custom comparator``    ``pq ``=` `queue.PriorityQueue()` `    ``# Populating the priority queue``    ``for` `i ``in` `range``(size):``        ``newNode ``=` `HuffmanTreeNode(data[i], freq[i])``        ``pq.put(newNode)` `    ``# Generate Huffman Encoding Tree and get the root node``    ``root ``=` `generateTree(pq)` `    ``# Print Huffman Codes``    ``arr ``=` `[``0``] ``*` `MAX_SIZE``    ``top ``=` `0``    ``printCodes(root, arr, top)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``data ``=` `[``'a'``, ``'b'``, ``'c'``, ``'d'``, ``'e'``, ``'f'``]``    ``freq ``=` `[``5``, ``9``, ``12``, ``13``, ``16``, ``45``]``    ``size ``=` `len``(data)` `    ``HuffmanCodes(data, freq, size)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `class` `HuffmanTreeNode``    ``: IComparable {``    ``public` `char` `Data``    ``{``        ``get``;``        ``set``;``    ``}``    ``public` `int` `Freq``    ``{``        ``get``;``        ``set``;``    ``}``    ``public` `HuffmanTreeNode Left``    ``{``        ``get``;``        ``set``;``    ``}``    ``public` `HuffmanTreeNode Right``    ``{``        ``get``;``        ``set``;``    ``}` `    ``public` `HuffmanTreeNode(``char` `character, ``int` `frequency)``    ``{``        ``Data = character;``        ``Freq = frequency;``        ``Left = Right = ``null``;``    ``}` `    ``public` `int` `CompareTo(HuffmanTreeNode other)``    ``{``        ``return` `Freq - other.Freq;``    ``}``}` `public` `class` `GFG {``    ``// Maximum Height of Huffman Tree.``    ``private` `const` `int` `MaxSize = 100;` `    ``// Function to print the huffman code for each``    ``// character. It uses arr to store the codes``    ``private` `static` `void` `PrintCodes(HuffmanTreeNode root,``                                   ``int``[] arr, ``int` `top)``    ``{``        ``// Assign 0 to the left node and recur``        ``if` `(root.Left != ``null``) {``            ``arr[top] = 0;``            ``PrintCodes(root.Left, arr, top + 1);``        ``}` `        ``// Assign 1 to the right node and recur``        ``if` `(root.Right != ``null``) {``            ``arr[top] = 1;``            ``PrintCodes(root.Right, arr, top + 1);``        ``}` `        ``// If this is a leaf node, then we print root.Data``        ``// We also print the code for this character from``        ``// arr``        ``if` `(root.Left == ``null` `&& root.Right == ``null``) {``            ``Console.Write(root.Data + ``" "``);``            ``for` `(``int` `i = 0; i < top; ++i) {``                ``Console.Write(arr[i]);``            ``}``            ``Console.WriteLine();``        ``}``    ``}` `    ``// Function to generate Huffman Encoding Tree``    ``private` `static` `HuffmanTreeNode``    ``GenerateTree(SortedList<``int``, HuffmanTreeNode> list)``    ``{``        ``// We keep on looping till only one node remains in``        ``// the SortedList``        ``while` `(list.Count != 1) {``            ``// Node which has least frequency``            ``HuffmanTreeNode left = list.Values[0];``            ``list.RemoveAt(0);` `            ``// Node which has least frequency``            ``HuffmanTreeNode right = list.Values[0];``            ``list.RemoveAt(0);` `            ``// A new node is formed with frequency left.Freq``            ``// + right.Freq We take data as '\$' because we``            ``// are only concerned with the frequency``            ``HuffmanTreeNode node = ``new` `HuffmanTreeNode(``                ``'\$'``, left.Freq + right.Freq);``            ``node.Left = left;``            ``node.Right = right;` `            ``// Add the new node back to the SortedList``            ``list.Add(node.Freq, node);``        ``}` `        ``return` `list.Values[0];``    ``}` `    ``// Function to generate Huffman Codes``    ``public` `static` `void` `HuffmanCodes(``char``[] data, ``int``[] freq,``                                    ``int` `size)``    ``{``        ``// Declaring SortedList using custom comparer``        ``SortedList<``int``, HuffmanTreeNode> list``            ``= ``new` `SortedList<``int``, HuffmanTreeNode>();` `        ``// Populating the SortedList``        ``for` `(``int` `i = 0; i < size; i++) {``            ``HuffmanTreeNode newNode``                ``= ``new` `HuffmanTreeNode(data[i], freq[i]);``            ``list.Add(freq[i], newNode);``        ``}` `        ``// Generate Huffman Encoding Tree and get the root``        ``// node``        ``HuffmanTreeNode root = GenerateTree(list);` `        ``// Print Huffman Codes``        ``int``[] arr = ``new` `int``[MaxSize];``        ``int` `top = 0;``        ``PrintCodes(root, arr, top);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``char``[] data = { ``'a'``, ``'b'``, ``'c'``, ``'d'``, ``'e'``, ``'f'` `};``        ``int``[] freq = { 5, 9, 12, 13, 16, 45 };``        ``int` `size = data.Length;` `        ``// Function call``        ``HuffmanCodes(data, freq, size);``    ``}``}`

## Javascript

 `// javascript Program for Huffman Coding``// using Priority Queue` `class HuffmanTreeNode {``    ` `  ``// Initializing the``  ``// current node``  ``constructor(character, frequency) {``      ` `    ``// Stores character``    ``this``.data = character;``    ` `    ``// Stores frequency of``    ``// the character``    ``this``.freq = frequency;``    ` `    ``// Left child of the``    ``// current node``    ``this``.left = ``null``;``    ` `    ``// Right child of the``    ``// current node``    ``this``.right = ``null``;``  ``}``}` `// Custom comparator class``class Compare {``  ``constructor() {}``  ``static compare(a, b) {``      ` `    ``// Defining priority on``    ``// the basis of frequency``    ``return` `a.freq - b.freq;``  ``}``}` `// Function to generate Huffman``// Encoding Tree``function` `generateTree(pq) { ``    ` `    ` `  ``// We keep on looping till``  ``// only one node remains in``  ``// the Priority Queue``  ``while` `(pq.length > 1) {``      ` `    ``// Node which has least``    ``// frequency``    ``const left = pq.shift();``    ` `    ``// Remove node from``    ``// Priority Queue``    ``const right = pq.shift();``    ` `    ` `    ``// A new node is formed``    ``// with frequency left->freq``    ``// + right->freq``    ` `    ``// We take data as '\$'``    ``// because we are only``    ``// concerned with the``    ``// frequency``    ``const node = ``new` `HuffmanTreeNode(``'\$'``, left.freq + right.freq);``    ``node.left = left;``    ``node.right = right;``    ` `    ``// Push back node``    ``// created to the``    ``// Priority Queue``    ``pq.push(node);``    ``pq.sort(Compare.compare);``  ``}``  ``return` `pq[0];``}`  `// Function to print the``// huffman code for each``// character.` `// It uses arr to store the codes``function` `printCodes(root, arr, top) {``    ` `    ` `  ``// Assign 0 to the left node``  ``// and recur``  ``if` `(root.left) {``    ``arr[top] = 0;``    ``printCodes(root.left, arr, top + 1);``  ``}`  `  ``// Assign 1 to the right``  ``// node and recur``  ``if` `(root.right) {``    ``arr[top] = 1;``    ``printCodes(root.right, arr, top + 1);``  ``}`  `  ``// If this is a leaf node,``  ``// then we print root->data` `  ``// We also print the code``  ``// for this character from arr``  ``if` `(!root.left && !root.right) {``    ``console.log(root.data + ``' '` `+ arr.slice(0, top).join(``''``));``  ``}``}` `function` `HuffmanCodes(data, freq, size) {``    ` `  ``// Maximum Height of Huffman Tree.``  ``const MAX_SIZE = 100;``  ` `  ``// Declaring priority queue``  ``// using custom comparator``  ``const pq = [];``  ` `  ``// Populating the priority``  ``// queue``  ``for` `(let i = 0; i < size; i++) {``    ``const newNode = ``new` `HuffmanTreeNode(data[i], freq[i]);``    ``pq.push(newNode);``  ``}``  ``pq.sort(Compare.compare);``  ` `  ``// Generate Huffman Encoding``  ``// Tree and get the root node``  ``const root = generateTree(pq);``  ``const arr = ``new` `Array(MAX_SIZE);``  ``const top = 0;``  ` `  ``// Print Huffman Codes``  ``printCodes(root, arr, top);``}`  `// Driver Code``const data = [``'a'``, ``'b'``, ``'c'``, ``'d'``, ``'e'``, ``'f'``];``const freq = [5, 9, 12, 13, 16, 45];``const size = data.length;` `HuffmanCodes(data, freq, size);`  `// This code is contributed by shiv1o43g`

Output:

```f 0
c 100
d 101
a 1100
b 1101
e 111```

Time Complexity: O(n*logn) where n is the number of unique characters
Auxiliary Space: O(n)

My Personal Notes arrow_drop_up