From 3a80d4c3feec4899bc128cc1d1aa9d82f019e9bf Mon Sep 17 00:00:00 2001 From: likun-3993 <76272089+likun-3993@users.noreply.github.com> Date: Fri, 28 Oct 2022 20:22:11 +0530 Subject: [PATCH 1/2] Add files via upload --- Searching Algo/bfs.cpp | 71 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 Searching Algo/bfs.cpp diff --git a/Searching Algo/bfs.cpp b/Searching Algo/bfs.cpp new file mode 100644 index 00000000..b628e832 --- /dev/null +++ b/Searching Algo/bfs.cpp @@ -0,0 +1,71 @@ +#include +using namespace std; + +class Graph +{ + int V; + vector> adj; + +public: + Graph(int V); + void addEdge(int v, int w); + void BFS(int s); +}; + +Graph::Graph(int V) +{ + this->V = V; + adj.resize(V); +} + +void Graph::addEdge(int v, int w) +{ + adj[v].push_back(w); +} + +void Graph::BFS(int s) +{ + + vector visited; + visited.resize(V, false); + + list queue; + + visited[s] = true; + queue.push_back(s); + + while (!queue.empty()) + { + + s = queue.front(); + cout << s << " "; + queue.pop_front(); + + for (auto adjecent : adj[s]) + { + if (!visited[adjecent]) + { + visited[adjecent] = true; + queue.push_back(adjecent); + } + } + } +} + +int main() +{ + + Graph g(4); + g.addEdge(0, 1); + g.addEdge(0, 2); + g.addEdge(1, 2); + g.addEdge(2, 0); + g.addEdge(2, 3); + g.addEdge(3, 3); + + cout << "Following is Breadth First Traversal " + << "(starting from vertex 2) \n"; + g.BFS(2); + + return 0; +} From fffb7267ea23fd353e927fb2b248968690e837b4 Mon Sep 17 00:00:00 2001 From: likun-3993 <76272089+likun-3993@users.noreply.github.com> Date: Fri, 28 Oct 2022 20:49:32 +0530 Subject: [PATCH 2/2] added the hoffman encoding problem --- Trees Algorithm/hoffman.c | 289 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 289 insertions(+) create mode 100644 Trees Algorithm/hoffman.c diff --git a/Trees Algorithm/hoffman.c b/Trees Algorithm/hoffman.c new file mode 100644 index 00000000..495b9238 --- /dev/null +++ b/Trees Algorithm/hoffman.c @@ -0,0 +1,289 @@ +#include +#include + +// This constant can be avoided by explicitly +// calculating height of Huffman Tree +#define MAX_TREE_HT 100 + +// A Huffman tree node +struct MinHeapNode +{ + + // One of the input characters + char data; + + // Frequency of the character + unsigned freq; + + // Left and right child of this node + struct MinHeapNode *left, *right; +}; + +// A Min Heap: Collection of +// min-heap (or Huffman tree) nodes +struct MinHeap +{ + + // Current size of min heap + unsigned size; + + // capacity of min heap + unsigned capacity; + + // Array of minheap node pointers + struct MinHeapNode **array; +}; + +// A utility function allocate a new +// min heap node with given character +// and frequency of the character +struct MinHeapNode *newNode(char data, unsigned freq) +{ + struct MinHeapNode *temp = (struct MinHeapNode *)malloc( + sizeof(struct MinHeapNode)); + + temp->left = temp->right = NULL; + temp->data = data; + temp->freq = freq; + + return temp; +} + +// A utility function to create +// a min heap of given capacity +struct MinHeap *createMinHeap(unsigned capacity) + +{ + + struct MinHeap *minHeap = (struct MinHeap *)malloc(sizeof(struct MinHeap)); + + // current size is 0 + minHeap->size = 0; + + minHeap->capacity = capacity; + + minHeap->array = (struct MinHeapNode **)malloc( + minHeap->capacity * sizeof(struct MinHeapNode *)); + return minHeap; +} + +void swapMinHeapNode(struct MinHeapNode **a, + struct MinHeapNode **b) + +{ + struct MinHeapNode *t = *a; + *a = *b; + *b = t; +} + +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) + { + swapMinHeapNode(&minHeap->array[smallest], + &minHeap->array[idx]); + minHeapify(minHeap, smallest); + } +} + +int isSizeOne(struct MinHeap *minHeap) +{ + + return (minHeap->size == 1); +} + +struct MinHeapNode *extractMin(struct MinHeap *minHeap) + +{ + + struct MinHeapNode *temp = minHeap->array[0]; + minHeap->array[0] = minHeap->array[minHeap->size - 1]; + + --minHeap->size; + minHeapify(minHeap, 0); + + return temp; +} + +// A utility function to insert +// a new node to Min Heap +void insertMinHeap(struct MinHeap *minHeap, + struct MinHeapNode *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; +} + +// A standard function to build min heap +void buildMinHeap(struct MinHeap *minHeap) + +{ + + int n = minHeap->size - 1; + int i; + + for (i = (n - 1) / 2; i >= 0; --i) + minHeapify(minHeap, i); +} + +// A utility function to print an array of size n +void printArr(int arr[], int n) +{ + int i; + for (i = 0; i < n; ++i) + printf("%d", arr[i]); + + printf("\n"); +} + +// Utility function to check if this node is leaf +int isLeaf(struct MinHeapNode *root) + +{ + + return !(root->left) && !(root->right); +} + +// Creates a min heap of capacity +// equal to size and inserts all character of +// data[] in min heap. Initially size of +// min heap is equal to capacity +struct MinHeap *createAndBuildMinHeap(char data[], + int freq[], int size) + +{ + + struct MinHeap *minHeap = createMinHeap(size); + + for (int i = 0; i < size; ++i) + minHeap->array[i] = newNode(data[i], freq[i]); + + minHeap->size = size; + buildMinHeap(minHeap); + + return minHeap; +} + +// The main function that builds Huffman tree +struct MinHeapNode *buildHuffmanTree(char data[], + int freq[], int size) + +{ + struct MinHeapNode *left, *right, *top; + + // Step 1: Create a min heap of capacity + // equal to size. Initially, there are + // modes equal to size. + struct MinHeap *minHeap = createAndBuildMinHeap(data, freq, size); + + // Iterate while size of heap doesn't become 1 + while (!isSizeOne(minHeap)) + { + + // Step 2: Extract the two minimum + // freq items from min heap + left = extractMin(minHeap); + right = extractMin(minHeap); + + // Step 3: Create a new internal + // node with frequency equal to the + // sum of the two nodes frequencies. + // Make the two extracted node as + // left and right children of this new node. + // Add this node to the min heap + // '$' is a special value for internal nodes, not + // used + top = newNode('$', left->freq + right->freq); + + top->left = left; + top->right = right; + + insertMinHeap(minHeap, top); + } + + // Step 4: The remaining node is the + // root node and the tree is complete. + return extractMin(minHeap); +} + +// Prints huffman codes from the root of Huffman Tree. +// It uses arr[] to store codes +void printCodes(struct MinHeapNode *root, int arr[], + int top) + +{ + + // Assign 0 to left edge and recur + if (root->left) + { + + arr[top] = 0; + printCodes(root->left, arr, top + 1); + } + + // Assign 1 to right edge and recur + if (root->right) + { + + arr[top] = 1; + printCodes(root->right, arr, top + 1); + } + + // If this is a leaf node, then + // it contains one of the input + // characters, print the character + // and its code from arr[] + if (isLeaf(root)) + { + + printf("%c: ", root->data); + printArr(arr, top); + } +} + +void HuffmanCodes(char data[], int freq[], int size) + +{ + + struct MinHeapNode *root = buildHuffmanTree(data, freq, size); + + int arr[MAX_TREE_HT], top = 0; + + printCodes(root, arr, top); +} + +int main() +{ + + char arr[] = {'a', 'b', 'c', 'd', 'e', 'f'}; + int freq[] = {5, 9, 12, 13, 16, 45}; + + int size = sizeof(arr) / sizeof(arr[0]); + + HuffmanCodes(arr, freq, size); + + return 0; +}