From aa26648bee3c27d43165b7f1d086954e83226a5a Mon Sep 17 00:00:00 2001
From: jhuynh06 <111946833+jhuynh06@users.noreply.github.com>
Date: Fri, 28 Oct 2022 22:56:35 -0700
Subject: [PATCH 1/4] Update README.md

---
 .../Longest Common Subsequence/README.md      | 59 -------------------
 1 file changed, 59 deletions(-)

diff --git a/Algorithms/Dynamic Programming/Longest Common Subsequence/README.md b/Algorithms/Dynamic Programming/Longest Common Subsequence/README.md
index 57fc46ea..c5724663 100644
--- a/Algorithms/Dynamic Programming/Longest Common Subsequence/README.md	
+++ b/Algorithms/Dynamic Programming/Longest Common Subsequence/README.md	
@@ -56,7 +56,6 @@ else
 ## Implementation:
 
 * [C](#c)
-* [C++](#cpp)
 * [Python](#python)
 * [C#](#cSharp)
 
@@ -127,64 +126,6 @@ int main() {
 ```
 
 
-## C++ 
-
-```cpp
-// C++ Program for longest common subsequence
-
-#include <iostream>
-using namespace std;
-
-void lcsAlgo(char *S1, char *S2, int m, int n) {
-  int LCS_table[m + 1][n + 1];
-
-
-  // Building the mtrix in bottom-up way
-  for (int i = 0; i <= m; i++) {
-    for (int j = 0; j <= n; j++) {
-      if (i == 0 || j == 0)
-        LCS_table[i][j] = 0;
-      else if (S1[i - 1] == S2[j - 1])
-        LCS_table[i][j] = LCS_table[i - 1][j - 1] + 1;
-      else
-        LCS_table[i][j] = max(LCS_table[i - 1][j], LCS_table[i][j - 1]);
-    }
-  }
-
-  int index = LCS_table[m][n];
-  char lcsAlgo[index + 1];
-  lcsAlgo[index] = '\0';
-
-  int i = m, j = n;
-  while (i > 0 && j > 0) {
-    if (S1[i - 1] == S2[j - 1]) {
-      lcsAlgo[index - 1] = S1[i - 1];
-      i--;
-      j--;
-      index--;
-    }
-
-    else if (LCS_table[i - 1][j] > LCS_table[i][j - 1])
-      i--;
-    else
-      j--;
-  }
-  
-  // Printing the sub sequences
-  cout << "S1 : " << S1 << "\nS2 : " << S2 << "\nLCS: " << lcsAlgo << "\n";
-}
-
-int main() {
-  char S1[] = "ACDABCD";
-  char S2[] = "ADBCA";
-  int m = strlen(S1);
-  int n = strlen(S2);
-
-  lcsAlgo(S1, S2, m, n);
-}
-
-```
-
 ## Python 
 
 ```python

From cca53dc166920df0d026894b36680eb7358b9722 Mon Sep 17 00:00:00 2001
From: jhuynh06 <111946833+jhuynh06@users.noreply.github.com>
Date: Sat, 29 Oct 2022 01:05:21 -0700
Subject: [PATCH 2/4] Revert "Update README.md"

---
 .../Longest Common Subsequence/README.md      | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/Algorithms/Dynamic Programming/Longest Common Subsequence/README.md b/Algorithms/Dynamic Programming/Longest Common Subsequence/README.md
index c5724663..57fc46ea 100644
--- a/Algorithms/Dynamic Programming/Longest Common Subsequence/README.md	
+++ b/Algorithms/Dynamic Programming/Longest Common Subsequence/README.md	
@@ -56,6 +56,7 @@ else
 ## Implementation:
 
 * [C](#c)
+* [C++](#cpp)
 * [Python](#python)
 * [C#](#cSharp)
 
@@ -126,6 +127,64 @@ int main() {
 ```
 
 
+## C++ 
+
+```cpp
+// C++ Program for longest common subsequence
+
+#include <iostream>
+using namespace std;
+
+void lcsAlgo(char *S1, char *S2, int m, int n) {
+  int LCS_table[m + 1][n + 1];
+
+
+  // Building the mtrix in bottom-up way
+  for (int i = 0; i <= m; i++) {
+    for (int j = 0; j <= n; j++) {
+      if (i == 0 || j == 0)
+        LCS_table[i][j] = 0;
+      else if (S1[i - 1] == S2[j - 1])
+        LCS_table[i][j] = LCS_table[i - 1][j - 1] + 1;
+      else
+        LCS_table[i][j] = max(LCS_table[i - 1][j], LCS_table[i][j - 1]);
+    }
+  }
+
+  int index = LCS_table[m][n];
+  char lcsAlgo[index + 1];
+  lcsAlgo[index] = '\0';
+
+  int i = m, j = n;
+  while (i > 0 && j > 0) {
+    if (S1[i - 1] == S2[j - 1]) {
+      lcsAlgo[index - 1] = S1[i - 1];
+      i--;
+      j--;
+      index--;
+    }
+
+    else if (LCS_table[i - 1][j] > LCS_table[i][j - 1])
+      i--;
+    else
+      j--;
+  }
+  
+  // Printing the sub sequences
+  cout << "S1 : " << S1 << "\nS2 : " << S2 << "\nLCS: " << lcsAlgo << "\n";
+}
+
+int main() {
+  char S1[] = "ACDABCD";
+  char S2[] = "ADBCA";
+  int m = strlen(S1);
+  int n = strlen(S2);
+
+  lcsAlgo(S1, S2, m, n);
+}
+
+```
+
 ## Python 
 
 ```python

From f85f828ed53ea7a636385fbcf7c958045513efc3 Mon Sep 17 00:00:00 2001
From: jhuynh06 <111946833+jhuynh06@users.noreply.github.com>
Date: Sat, 29 Oct 2022 01:56:49 -0700
Subject: [PATCH 3/4] Update readme.md

---
 .../Huffman Coding Algorithm/readme.md        | 186 ------------------
 1 file changed, 186 deletions(-)

diff --git a/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md b/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md
index 7244a568..9f1af528 100644
--- a/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md	
+++ b/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md	
@@ -46,7 +46,6 @@ Extracting minimum frequency from the priority queue takes place 2*(n-1) times a
 
 ## Implementations
 * [C++](#cpp)
-* [C](#c)
 * [Java](#java)
 * [Python](#python)
 
@@ -234,191 +233,6 @@ int main() {
 }
 ```
 
-### C
-```c
-// Huffman Coding in C
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#define MAX_TREE_HT 50
-
-struct MinHNode {
-  char item;
-  unsigned freq;
-  struct MinHNode *left, *right;
-};
-
-struct MinHeap {
-  unsigned size;
-  unsigned capacity;
-  struct MinHNode **array;
-};
-
-// 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
-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;
-}
-
-// Function to swap
-void swapMinHNode(struct MinHNode **a, struct MinHNode **b) {
-  struct MinHNode *t = *a;
-  *a = *b;
-  *b = t;
-}
-
-// Heapify
-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]);
-    minHeapify(minHeap, smallest);
-  }
-}
-
-// Check if size if 1
-int checkSizeOne(struct MinHeap *minHeap) {
-  return (minHeap->size == 1);
-}
-
-// 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 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;
-}
-
-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 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 *buildHuffmanTree(char item[], int freq[], int size) {
-  struct MinHNode *left, *right, *top;
-  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);
-}
-
-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);
-    printArray(arr, top);
-  }
-}
-
-// Wrapper function
-void HuffmanCodes(char item[], int freq[], int size) {
-  struct MinHNode *root = buildHuffmanTree(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");
-
-  HuffmanCodes(arr, freq, size);
-}
-```
-
 ### Java
 ```java
 // Huffman Coding in Java

From e35c19c40554d1fdab45bd99de7688b1e95f6f2d Mon Sep 17 00:00:00 2001
From: Sifat <hossain0338@gmail.com>
Date: Sat, 29 Oct 2022 15:42:58 +0600
Subject: [PATCH 4/4] Fix c code

---
 .../Huffman Coding Algorithm/readme.md        | 145 ++++++++++++++++++
 1 file changed, 145 insertions(+)

diff --git a/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md b/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md
index 9f1af528..26f9d139 100644
--- a/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md	
+++ b/Algorithms/Greedy Algorithm/Huffman Coding Algorithm/readme.md	
@@ -45,10 +45,155 @@ 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](#c)
 * [C++](#cpp)
 * [Java](#java)
 * [Python](#python)
 
+### 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 {
+  char item;
+  unsigned freq;
+  struct MinHNode *left, *right;
+};
+struct MinHeap {
+  unsigned size;
+  unsigned capacity;
+  struct MinHNode **array;
+};
+// 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
+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;
+}
+// Function to swap
+void swapMinHNode(struct MinHNode **a, struct MinHNode **b) {
+  struct MinHNode *t = *a;
+  *a = *b;
+  *b = t;
+}
+// Heapify
+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]);
+    minHeapify(minHeap, smallest);
+  }
+}
+// Check if size if 1
+int checkSizeOne(struct MinHeap *minHeap) {
+  return (minHeap->size == 1);
+}
+// 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 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;
+}
+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 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 *buildHuffmanTree(char item[], int freq[], int size) {
+  struct MinHNode *left, *right, *top;
+  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);
+}
+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);
+    printArray(arr, top);
+  }
+}
+// Wrapper function
+void HuffmanCodes(char item[], int freq[], int 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]);
+  printf(" Char | Huffman code ");
+  printf("\n--------------------\n");
+  HuffmanCodes(arr, freq, size);
+}
+```
+
 ### CPP
 ```cpp
 // Huffman Coding in C++