diff --git a/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md b/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md
index 7244a568..26f9d139 100644
--- a/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md	
+++ b/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md	
@@ -45,154 +45,119 @@ The time complexity for encoding each unique character based on its frequency is
 Extracting minimum frequency from the priority queue takes place 2*(n-1) times and its complexity is O(log n). Thus the overall complexity is O(nlog n).
 
 ## Implementations
-* [C++](#cpp)
 * [C](#c)
+* [C++](#cpp)
 * [Java](#java)
 * [Python](#python)
 
-### CPP
-```cpp
-// Huffman Coding in C++
-
-#include <iostream>
-using namespace std;
-
+### C
+```
+#include <stdio.h>
+#include <stdlib.h>
 #define MAX_TREE_HT 50
 
+// Print the array
+void printArray(int arr[], int n) {
+  int i;
+  for (i = 0; i < n; ++i)
+    printf("%d", arr[i]);
+  printf("\n");
+}
+
 struct MinHNode {
-  unsigned freq;
   char item;
+  unsigned freq;
   struct MinHNode *left, *right;
 };
-
-struct MinH {
+struct MinHeap {
   unsigned size;
   unsigned capacity;
   struct MinHNode **array;
 };
-
-// Creating Huffman tree node
+// Create nodes
 struct MinHNode *newNode(char item, unsigned freq) {
   struct MinHNode *temp = (struct MinHNode *)malloc(sizeof(struct MinHNode));
-
   temp->left = temp->right = NULL;
   temp->item = item;
   temp->freq = freq;
-
   return temp;
 }
-
-// Create min heap using given capacity
-struct MinH *createMinH(unsigned capacity) {
-  struct MinH *minHeap = (struct MinH *)malloc(sizeof(struct MinH));
+// Create min heap
+struct MinHeap *createMinH(unsigned capacity) {
+  struct MinHeap *minHeap = (struct MinHeap *)malloc(sizeof(struct MinHeap));
   minHeap->size = 0;
   minHeap->capacity = capacity;
   minHeap->array = (struct MinHNode **)malloc(minHeap->capacity * sizeof(struct MinHNode *));
   return minHeap;
 }
-
-// Print the array
-void printArray(int arr[], int n) {
-  int i;
-  for (i = 0; i < n; ++i)
-    cout << arr[i];
-
-  cout << "\n";
-}
-
-// Swap function
+// Function to swap
 void swapMinHNode(struct MinHNode **a, struct MinHNode **b) {
   struct MinHNode *t = *a;
   *a = *b;
   *b = t;
 }
-
 // Heapify
-void minHeapify(struct MinH *minHeap, int idx) {
+void minHeapify(struct MinHeap *minHeap, int idx) {
   int smallest = idx;
   int left = 2 * idx + 1;
   int right = 2 * idx + 2;
-
   if (left < minHeap->size && minHeap->array[left]->freq < minHeap->array[smallest]->freq)
     smallest = left;
-
   if (right < minHeap->size && minHeap->array[right]->freq < minHeap->array[smallest]->freq)
     smallest = right;
-
   if (smallest != idx) {
-    swapMinHNode(&minHeap->array[smallest],
-           &minHeap->array[idx]);
+    swapMinHNode(&minHeap->array[smallest], &minHeap->array[idx]);
     minHeapify(minHeap, smallest);
   }
 }
-
 // Check if size if 1
-int checkSizeOne(struct MinH *minHeap) {
+int checkSizeOne(struct MinHeap *minHeap) {
   return (minHeap->size == 1);
 }
-
-// Extract the min
-struct MinHNode *extractMin(struct MinH *minHeap) {
+// Extract min
+struct MinHNode *extractMin(struct MinHeap *minHeap) {
   struct MinHNode *temp = minHeap->array[0];
   minHeap->array[0] = minHeap->array[minHeap->size - 1];
-
   --minHeap->size;
   minHeapify(minHeap, 0);
-
   return temp;
 }
-
-// Insertion
-void insertMinHeap(struct MinH *minHeap, struct MinHNode *minHeapNode) {
+// Insertion function
+void insertMinHeap(struct MinHeap *minHeap, struct MinHNode *minHeapNode) {
   ++minHeap->size;
   int i = minHeap->size - 1;
-
   while (i && minHeapNode->freq < minHeap->array[(i - 1) / 2]->freq) {
     minHeap->array[i] = minHeap->array[(i - 1) / 2];
     i = (i - 1) / 2;
   }
-
   minHeap->array[i] = minHeapNode;
 }
-
-// BUild min heap
-void buildMinHeap(struct MinH *minHeap) {
+void buildMinHeap(struct MinHeap *minHeap) {
   int n = minHeap->size - 1;
   int i;
-
   for (i = (n - 1) / 2; i >= 0; --i)
     minHeapify(minHeap, i);
 }
-
 int isLeaf(struct MinHNode *root) {
   return !(root->left) && !(root->right);
 }
-
-struct MinH *createAndBuildMinHeap(char item[], int freq[], int size) {
-  struct MinH *minHeap = createMinH(size);
-
+struct MinHeap *createAndBuildMinHeap(char item[], int freq[], int size) {
+  struct MinHeap *minHeap = createMinH(size);
   for (int i = 0; i < size; ++i)
     minHeap->array[i] = newNode(item[i], freq[i]);
-
   minHeap->size = size;
   buildMinHeap(minHeap);
-
   return minHeap;
 }
-
-struct MinHNode *buildHfTree(char item[], int freq[], int size) {
+struct MinHNode *buildHuffmanTree(char item[], int freq[], int size) {
   struct MinHNode *left, *right, *top;
-  struct MinH *minHeap = createAndBuildMinHeap(item, freq, size);
-
+  struct MinHeap *minHeap = createAndBuildMinHeap(item, freq, size);
   while (!checkSizeOne(minHeap)) {
     left = extractMin(minHeap);
     right = extractMin(minHeap);
-
     top = newNode('$', left->freq + right->freq);
-
     top->left = left;
     top->right = right;
-
     insertMinHeap(minHeap, top);
   }
   return extractMin(minHeap);
@@ -202,60 +167,55 @@ void printHCodes(struct MinHNode *root, int arr[], int top) {
     arr[top] = 0;
     printHCodes(root->left, arr, top + 1);
   }
-
   if (root->right) {
     arr[top] = 1;
     printHCodes(root->right, arr, top + 1);
   }
   if (isLeaf(root)) {
-    cout << root->item << "  | ";
+    printf("  %c   | ", root->item);
     printArray(arr, top);
   }
 }
-
 // Wrapper function
 void HuffmanCodes(char item[], int freq[], int size) {
-  struct MinHNode *root = buildHfTree(item, freq, size);
-
+  struct MinHNode *root = buildHuffmanTree(item, freq, size);
   int arr[MAX_TREE_HT], top = 0;
-
   printHCodes(root, arr, top);
 }
 
+
 int main() {
   char arr[] = {'A', 'B', 'C', 'D'};
   int freq[] = {5, 1, 6, 3};
-
   int size = sizeof(arr) / sizeof(arr[0]);
-
-  cout << "Char | Huffman code ";
-  cout << "\n----------------------\n";
+  printf(" Char | Huffman code ");
+  printf("\n--------------------\n");
   HuffmanCodes(arr, freq, size);
 }
 ```
 
-### C
-```c
-// Huffman Coding in C
+### CPP
+```cpp
+// Huffman Coding in C++
 
-#include <stdio.h>
-#include <stdlib.h>
+#include <iostream>
+using namespace std;
 
 #define MAX_TREE_HT 50
 
 struct MinHNode {
-  char item;
   unsigned freq;
+  char item;
   struct MinHNode *left, *right;
 };
 
-struct MinHeap {
+struct MinH {
   unsigned size;
   unsigned capacity;
   struct MinHNode **array;
 };
 
-// Create nodes
+// Creating Huffman tree node
 struct MinHNode *newNode(char item, unsigned freq) {
   struct MinHNode *temp = (struct MinHNode *)malloc(sizeof(struct MinHNode));
 
@@ -266,19 +226,25 @@ struct MinHNode *newNode(char item, unsigned freq) {
   return temp;
 }
 
-// Create min heap
-struct MinHeap *createMinH(unsigned capacity) {
-  struct MinHeap *minHeap = (struct MinHeap *)malloc(sizeof(struct MinHeap));
-
+// Create min heap using given capacity
+struct MinH *createMinH(unsigned capacity) {
+  struct MinH *minHeap = (struct MinH *)malloc(sizeof(struct MinH));
   minHeap->size = 0;
-
   minHeap->capacity = capacity;
-
   minHeap->array = (struct MinHNode **)malloc(minHeap->capacity * sizeof(struct MinHNode *));
   return minHeap;
 }
 
-// Function to swap
+// Print the array
+void printArray(int arr[], int n) {
+  int i;
+  for (i = 0; i < n; ++i)
+    cout << arr[i];
+
+  cout << "\n";
+}
+
+// Swap function
 void swapMinHNode(struct MinHNode **a, struct MinHNode **b) {
   struct MinHNode *t = *a;
   *a = *b;
@@ -286,7 +252,7 @@ void swapMinHNode(struct MinHNode **a, struct MinHNode **b) {
 }
 
 // Heapify
-void minHeapify(struct MinHeap *minHeap, int idx) {
+void minHeapify(struct MinH *minHeap, int idx) {
   int smallest = idx;
   int left = 2 * idx + 1;
   int right = 2 * idx + 2;
@@ -298,18 +264,19 @@ void minHeapify(struct MinHeap *minHeap, int idx) {
     smallest = right;
 
   if (smallest != idx) {
-    swapMinHNode(&minHeap->array[smallest], &minHeap->array[idx]);
+    swapMinHNode(&minHeap->array[smallest],
+           &minHeap->array[idx]);
     minHeapify(minHeap, smallest);
   }
 }
 
 // Check if size if 1
-int checkSizeOne(struct MinHeap *minHeap) {
+int checkSizeOne(struct MinH *minHeap) {
   return (minHeap->size == 1);
 }
 
-// Extract min
-struct MinHNode *extractMin(struct MinHeap *minHeap) {
+// Extract the min
+struct MinHNode *extractMin(struct MinH *minHeap) {
   struct MinHNode *temp = minHeap->array[0];
   minHeap->array[0] = minHeap->array[minHeap->size - 1];
 
@@ -319,8 +286,8 @@ struct MinHNode *extractMin(struct MinHeap *minHeap) {
   return temp;
 }
 
-// Insertion function
-void insertMinHeap(struct MinHeap *minHeap, struct MinHNode *minHeapNode) {
+// Insertion
+void insertMinHeap(struct MinH *minHeap, struct MinHNode *minHeapNode) {
   ++minHeap->size;
   int i = minHeap->size - 1;
 
@@ -328,10 +295,12 @@ void insertMinHeap(struct MinHeap *minHeap, struct MinHNode *minHeapNode) {
     minHeap->array[i] = minHeap->array[(i - 1) / 2];
     i = (i - 1) / 2;
   }
+
   minHeap->array[i] = minHeapNode;
 }
 
-void buildMinHeap(struct MinHeap *minHeap) {
+// BUild min heap
+void buildMinHeap(struct MinH *minHeap) {
   int n = minHeap->size - 1;
   int i;
 
@@ -343,8 +312,8 @@ int isLeaf(struct MinHNode *root) {
   return !(root->left) && !(root->right);
 }
 
-struct MinHeap *createAndBuildMinHeap(char item[], int freq[], int size) {
-  struct MinHeap *minHeap = createMinH(size);
+struct MinH *createAndBuildMinHeap(char item[], int freq[], int size) {
+  struct MinH *minHeap = createMinH(size);
 
   for (int i = 0; i < size; ++i)
     minHeap->array[i] = newNode(item[i], freq[i]);
@@ -355,9 +324,9 @@ struct MinHeap *createAndBuildMinHeap(char item[], int freq[], int size) {
   return minHeap;
 }
 
-struct MinHNode *buildHuffmanTree(char item[], int freq[], int size) {
+struct MinHNode *buildHfTree(char item[], int freq[], int size) {
   struct MinHNode *left, *right, *top;
-  struct MinHeap *minHeap = createAndBuildMinHeap(item, freq, size);
+  struct MinH *minHeap = createAndBuildMinHeap(item, freq, size);
 
   while (!checkSizeOne(minHeap)) {
     left = extractMin(minHeap);
@@ -372,49 +341,39 @@ struct MinHNode *buildHuffmanTree(char item[], int freq[], int size) {
   }
   return extractMin(minHeap);
 }
-
 void printHCodes(struct MinHNode *root, int arr[], int top) {
   if (root->left) {
     arr[top] = 0;
     printHCodes(root->left, arr, top + 1);
   }
+
   if (root->right) {
     arr[top] = 1;
     printHCodes(root->right, arr, top + 1);
   }
   if (isLeaf(root)) {
-    printf("  %c   | ", root->item);
+    cout << root->item << "  | ";
     printArray(arr, top);
   }
 }
 
 // Wrapper function
 void HuffmanCodes(char item[], int freq[], int size) {
-  struct MinHNode *root = buildHuffmanTree(item, freq, size);
+  struct MinHNode *root = buildHfTree(item, freq, size);
 
   int arr[MAX_TREE_HT], top = 0;
 
   printHCodes(root, arr, top);
 }
 
-// Print the array
-void printArray(int arr[], int n) {
-  int i;
-  for (i = 0; i < n; ++i)
-    printf("%d", arr[i]);
-
-  printf("\n");
-}
-
 int main() {
   char arr[] = {'A', 'B', 'C', 'D'};
   int freq[] = {5, 1, 6, 3};
 
   int size = sizeof(arr) / sizeof(arr[0]);
 
-  printf(" Char | Huffman code ");
-  printf("\n--------------------\n");
-
+  cout << "Char | Huffman code ";
+  cout << "\n----------------------\n";
   HuffmanCodes(arr, freq, size);
 }
 ```