Merge branch 'main' into python_pigeonhole_sort

Author: peaky76

C++/Algorithms/Graph-Algorithms/Transitive_Closure.cpp

@@ -0,0 +1,83 @@
+#include <iostream>
+#include <vector>
+#include <cstring>
+#include <iomanip>
+using namespace std;
+
+// Number of vertices in the graph
+#define N 4
+
+// data structure to store graph edges
+struct Edge {
+int src, dest;
+};
+
+// class to represent a graph object
+class Graph
+{
+public:
+// An array of vectors to represent adjacency list
+vector<int> adjList[N];
+
+// Constructor
+Graph(vector<Edge> edges)
+{
+// add edges to the directed graph
+for (Edge edge: edges)
+{
+int src = edge.src;
+int dest = edge.dest;
+
+adjList[src].push_back(dest);
+}
+}
+};
+
+// C is connectivity matrix and stores transitive closure of graph
+// root is the topmost node in DFS tree(it is starting vertex of DFS)
+// descendent is current vertex to be explored in DFS
+// Invariant: A path already exists from root -> descendent in graph
+void DFS(Graph const& graph, bool C[N][N], int root, int descendent)
+{
+for (int child : graph.adjList[descendent])
+{
+// if child is an adjacent vertex of descendent, we have
+// found a path from root->child
+if (!C[root][child])
+{
+C[root][child] = true;
+DFS(graph, C, root, child);
+}
+}
+}
+
+int main()
+{
+// array of graph edges as per above diagram
+vector<Edge> edges = {
+{ 0, 2 }, { 1, 0 }, { 3, 1 }
+};
+
+// create a graph from edges
+Graph graph(edges);
+
+// C is connectivity matrix and stores the transitive closure
+// of the graph. The value of C[i][j] is 1 only if a directed
+// path exists from vertex i to vertex j.
+bool C[N][N];
+memset(C, false, sizeof C);
+
+// consider each vertex and start DFS from it
+for (int v = 0; v < N; v++)
+{
+C[v][v] = true;
+DFS(graph, C, v, v);
+
+// print path info for vertex v
+for (int u = 0; u < N; u++)
+cout << left << setw(4) << C[v][u];
+cout << endl;
+}
+
+return 0;
+}

C++/Algorithms/Greedy-Algorithms/Huffman.cpp

@@ -0,0 +1,283 @@
+#include <iostream> 
+#include <cstdlib> 
+using namespace std; 
+
+
+#define MAX_TREE_HT 100 
+
+struct MinHeapNode { 
+char data; 
+unsigned freq; 
+
+// Left and right child of this node 
+struct MinHeapNode *left, *right; 
+}; 
+
+struct MinHeap { 
+
+// Current size of min heap 
+unsigned size; 
+
+// capacity of min heap 
+unsigned capacity; 
+
+// Attay of minheap node pointers 
+struct MinHeapNode** array; 
+}; 
+
+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; 
+} 
+
+struct MinHeap* createMinHeap(unsigned capacity) 
+
+{ 
+
+struct MinHeap* minHeap 
+= (struct MinHeap*)malloc(sizeof(struct MinHeap)); 
+
+
+minHeap->size = 0; 
+
+minHeap->capacity = capacity; 
+
+minHeap->array 
+= (struct MinHeapNode**)malloc(minHeap-> 
+capacity * sizeof(struct MinHeapNode*)); 
+return minHeap; 
+} 
+
+// A utility function to 
+// swap two min heap nodes 
+void swapMinHeapNode(struct MinHeapNode** a, 
+struct MinHeapNode** b) 
+
+{ 
+
+struct MinHeapNode* t = *a; 
+*a = *b; 
+*b = t; 
+} 
+
+// The standard minHeapify function. 
+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); 
+} 
+} 
+
+// A utility function to check 
+// if size of heap is 1 or not 
+int isSizeOne(struct MinHeap* minHeap) 
+{ 
+
+return (minHeap->size == 1); 
+} 
+
+// A standard function to extract 
+// minimum value node from heap 
+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) 
+cout<< arr[i]; 
+
+cout<<"\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)) { 
+
+cout<< root->data <<": "; 
+printArr(arr, top); 
+} 
+} 
+
+void HuffmanCodes(char data[], int freq[], int size) 
+
+{ 
+// Construct Huffman Tree 
+struct MinHeapNode* root 
+= buildHuffmanTree(data, freq, size); 
+
+// Print Huffman codes using 
+// the Huffman tree built above 
+int arr[MAX_TREE_HT], top = 0; 
+
+printCodes(root, arr, top); 
+} 
+
+// Driver program to test above functions 
+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; 
+} 

C++/Algorithms/Resolution/24to8bit.CPP

@@ -0,0 +1,23 @@
+#include <opencv2/opencv.hpp>
+using namespace cv;
+
+int main( int argc, char** argv )
+{
+ char* ImageFile = argv[1]; //image file 
+	Mat image; //mat object for storing data
+	image = imread( ImageFile, IMREAD_COLOR ); //read the image file
+ if( argc != 2 || !image.data )
+	{
+ printf( " No image data \n " );
+ return -1;
+	}
+	Mat gray_image;
+ cvtColor( image, gray_image, COLOR_BGR2GRAY ); //convert image from colour to grey
+ imwrite( "/home/crmgogo/Pictures/greyImage.png", gray_image );
+ namedWindow( ImageFile, WINDOW_AUTOSIZE );
+ namedWindow( "Gray image", WINDOW_AUTOSIZE );
+ imshow( ImageFile, image ); //show window containing images
+ imshow( "Gray image", gray_image );
+ waitKey(0); //to exit
+ return 0;
+}