Huffman Coding 
 

Introduction 
Huffman Coding is one approach followed for T
​ ext Compression. ​Text 
compression means reducing the space requirement for saving a particular text. 

Huffman Coding is a lossless data compression algorithm, ie. it is a way of 

compressing data without the data losing any information in the process. It is 
useful in cases where there is a series of frequently occurring characters. 

Working of Huffman Algorithm: 

Suppose, the given string is: 

Here, each of the characters of the string takes 8 bits of memory. Since there are a 
total of 15 characters in the string so the total memory consumption will be 15*8 = 
120 bits. Let’s try to compress its size using the Huffman Algorithm. 

First-of-all, Huffman Coding creates a tree by calculating the frequencies of each 

character of the string and then assigns them some unique code so that we can 
retrieve the data back using these codes. 

Follow the steps below: 

 
1 
  

1. Begin with calculating the frequency of each character value in the given 
string. 

2. Sort the characters in ascending order concerning their frequency and store 
them in a priority queue, say Q
​ .   
3. Each character should be considered as a different leaf node. 

4. Make an empty node, say z​ ​. The left child of z is marked as the minimum 
frequency and the right child, the second minimum frequency. The value of z 
is calculated by summing up the first two frequencies. 

 
2 
  

Here, “.” denote the internal nodes. 

5. Now, remove the two characters with the lowest frequencies from the 
priority queue ​Q a
​ nd append their sum to the same. 
6. Simply insert the above node​ z​ to the tree. 
7. For every character in the string, repeat steps 3 to 5. 

 
3 
  

8. Assign 0 to the left side and 1 to the right side except for the leaf nodes. 

 
4 
  

The size table is given below: 

Character  Frequency  Code  Size 

A  5  11  5*2 = 10 

B  1  100  1*3 = 3 

C  6  0  6*1 = 6 

D  3  101  3*3 = 9 

4*8 = 32 bits  15 bits    28 bits 

Size before encoding:​ 120 bits 

Size after encoding:​ 32 + 15 + 28 = 75 bits 

To decode the code, simply traverse through the tree (starting from the root) 
to find the character. Suppose we want to decode 101, then: 

Time complexity: 
In the case of encoding, inserting each character into the priority queue takes 
O(log n​) time. Therefore, for the complete array, the time complexity becomes 
O(nlog(n))​. 

 
5 
  

Similarly, extraction of the element from the priority queue takes O

​ (log n)​ time. 
Hence, for the complete array, the achieved time complexity is ​O(nlog n)​. 

Python Code: 
Go through the given Python code, for deeper understanding: 

# Huffman Coding in python

string = ​'BCAADDDCCACACAC'​ ​#String similar to the above-taken example

# Creating tree nodes

class​ ​NodeTree​(object):

​def​ ​__init__​(self, left=None, right=None):

self.left = left
self.right = right

​def​ ​children​(self): ​#Return children of a node

​return​ (self.left, self.right)

​def​ ​nodes​(self):
​return​ (self.left, self.right)

​def​ ​__str__​(self):
​return​ ​'%s_%s'​ % (self.left, self.right)

# Main function implementing huffman coding

def​ ​huffman_code_tree​(node, left=True, binString=​''​):
​if​ type(node) ​is​ str:
​return​ {node: binString}
(l, r) = node.children()
d = dict()
d.update(huffman_code_tree(l, ​True​, binString + ​'0'​))
d.update(huffman_code_tree(r, ​False​, binString + ​'1'​))
​return​ d

 
6 
  

# Calculating frequency
freq = {}
for​ c ​in​ string:
​if​ c ​in​ freq:
freq[c] += ​1
​else​:
freq[c] = ​1

freq = sorted(freq.items(), key=​lambda​ x: x[​1​], reverse=​True​)

nodes = freq

while​ len(nodes) > ​1​:

(key1, c1) = nodes[​-1​]
(key2, c2) = nodes[​-2​]
nodes = nodes[:​-2​]
node = NodeTree(key1, key2)
nodes.append((node, c1 + c2))

nodes = sorted(nodes, key=​lambda​ x: x[​1​], reverse=​True​)

huffmanCode = huffman_code_tree(nodes[​0​][​0​])

print(​' Char | Huffman code '​)

print(​'----------------------'​)
for​ (char, frequency) ​in​ freq:
print(​' %-4r |%12s'​ % (char, huffmanCode[char])) 

Applications of Huffman Coding: 

● They are used for transmitting fax and text. 
● They are used by conventional compression formats like PKZIP, GZIP, etc.  

 
 

 
7