new questions added

Author: arorarahul

README.md

@@ -400,14 +400,15 @@ use KMP
 - [Make a program to implement huffman encoding](/greedy/question2.c)
 - [Make a program to sequence given jobs with deadlines to maximize profits](/greedy/question3.c)
 - [Optimal merge patterns](/greedy/question4.c)
-- [Program for PRIMS algorithm](/greedy/question5.c)
+- [Program for PRIMS algorithm without min heap](/greedy/question5.c)
 - [Program for KRUSKALS algorithm](/greedy/question6.c)
 - [Program for DIJKSTRA algorithm](/greedy/question7.c)
 - [Program to implement a simple graph](/greedy/question8.c)
 - [Consider n-ropes with different length. Find algo to tie up all the rope into a single rope with min cost](/greedy/question9.c)
 - [Find max intervals from given intervals such that none of them are overlapping](/greedy/question10.c)
 - [Number of railway platforms](/greedy/question11.c)
 - [Rearrange the string such that same characters are d distance away](/greedy/question12.c)
+- [Program for PRIMS algorithm using min heap](/greedy/question13.c)
 
 ### Divide and conquer
 
@@ -458,6 +459,9 @@ use KMP
 - [Given a rod of length 'n' inches and an array of prices that contains prices of all pieces of size smaller than n, find the max value obtainable by cutting the rod and selling the pieces](/dynamic-programming/question32.c)
 - [Fibonacci series](/dynamic-programming/question33.c)
 - [Max product sub array](/dynamic-programming/question34.c)
+- [Finding the maximum square sub-matrix with all equal elements](/dynamic-programming/question35.c)
+- [All pair shortest path algorithm (Floyd Warshall)](/dynamic-programming/question36.c)
+- [Collect max coins from the grid in two traversals](/dynamic-programming/question37.c)
 
 ### Graphs
 
@@ -472,7 +476,13 @@ use KMP
 - [Kosaraju algorithm to find SCCs](/graphs/question9.c)
 - [Find if the given directed graph is eulerian](/graphs/question10.c)
 - [Find if the given undirected graph is eulerian](/graphs/question11.c)
-- [Dijkstra algorithm](/graphs/question12.c)
+- [Dijkstra algorithm for matrix](/graphs/question12.c)
+- [Dijkstra algorithm for adjacency list](/graphs/question13.c)
+- [Articulation points and bridges in a graph](/graphs/question13.c)
+- [Print all jumping numbers smaller than or equal to a given value](/graphs/question15.c)
+- [Shortest path in directed acyclic graph](/graphs/question16.c)
+- [Longest path in directed acyclic graph](/graphs/question17.c)
+- [Hamiltonian cycle in a graph](/graphs/question18.c)
 
 ### Pattern Matching
 
@@ -491,12 +501,19 @@ use KMP
 
 - [Test whether given two strings are isomorphic or not](/misc/question1.c)
 - [Find the length of the longest suffix which is also a prefix](/misc/question2.c)
+- [Sort a stack](/misc/question66.c)
+- [Given two strings a and b print whether they contain any common subsequence (non empty) or not.](/misc/question67.c)
+
 
 ### Bit Manipulation
 
 - [Find set bits in an integer](/bit-manipulation/question1.c)
 - [Find if a number is a power of 2](/bit-manipulation/question2.c)
 
+
+### Trie
+
+
 ## Some important concepts to solve algos better
 
 - For extreme values refer to limits.h constants given by C

arrays/question3.c

@@ -9,58 +9,69 @@ Therefore: O(nlogn)
 
 */
 #include <stdio.h>
-#include <math.h>
-
-void merge(int arr[],int p, int q, int r){
-  long unsigned int f = INFINITY;
-  int n1= q-p+1;
-  int n2 = r-q;
-  int left[n1+1], right[n2+1];
-  int i,j,k;
-  
-  for(i=0;i<n1;i++){
-    left[i]=arr[p+i];
-    printf("%d ", left[i]);
-  }
-  
-  for(j=0;j<n2;j++){
-    right[j]=arr[q+j+1];
-    printf("%d ", right[j]);
-  } 
-  
-  left[n1] = right[n2] = f;
-  i=j=0;
-  for(k=p;k<(r+1);k++){
-    if(left[i] < right[j]){
-      arr[k] = left[i];
-      i++;
-    }else{
-      arr[k] = right[j];
-      j++;
+#include <stdlib.h>
+#include <limits.h>
+
+
+void merge(int *arr, int start, int mid, int end) {
+
+    int len1 = mid - start + 2;
+    int len2 = end - mid + 1;
+
+    int left[len1], right[len2];
+
+    int i;
+    for(i=0; i<len1-1; i++) {
+        left[i] = arr[start + i];
+    }
+
+    for(i=0; i<len2-1; i++) {
+        right[i] = arr[mid + i + 1];
     }
-  }
-  
-  for(int z=0; z<(r+1);z++){
-    printf("%d ", arr[z]);
-  }
-  
+    
+    left[len1-1] = INT_MAX;
+    right[len2-1] = INT_MAX;
+
+    int k;
+    int j;
+    i=0,j=0;
+    for(k=start; k<=end; k++) {
+        if(left[i] < right[j]) {
+            arr[k] = left[i];
+            i++;
+        }else{
+            arr[k] = right[j];
+            j++;
+        }
+    }
+
 }
 
-void merge_sort(int arr[], int p, int r){
-  
-  int q;
-  if(p<r){
-    q = (p+r)/2;
-    merge_sort(arr,p,q);
-    merge_sort(arr,q+1,r);
-    merge(arr,p,q,r);
-  }
+void mergeSort(int *arr, int start, int end) {
+    int mid;
+    if(start < end) {
+        mid = (start + end)/2;
+        mergeSort(arr, start, mid);
+        mergeSort(arr, mid + 1, end);
+
+        merge(arr, start, mid, end);
+    }
 }
 
-int main(){
-  
-  int arr[] = {9,6,5,0,8,2};
-  int length = sizeof(arr)/sizeof(arr[0]);
-  merge_sort(arr,0,length-1);
+void display(int *arr, int size) {
+    int i;
+    for(i=0;i<size;i++) {
+        printf("%d ", arr[i]);
+    }
+    printf("\n");
+}   
+
+int main() {
+    int arr[] = {9,6,5,0,8,2};
+    int size = sizeof(arr)/sizeof(arr[0]);
+
+    mergeSort(arr,0,size-1);
 
+    display(arr, size);
+    return 0;
 }

complex-datastructures/making-a-binary-search-tree.c

@@ -0,0 +1,215 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+struct node{
+	int data;
+	struct node *left;
+	struct node *right;
+};
+
+struct node *root;
+
+struct node *newNode(int data){
+	struct node *temp = (struct node *)malloc(sizeof(struct node));
+	temp->data = data;
+	temp->left = NULL;
+	temp->right = NULL;
+	return temp;
+}
+
+void search(struct node *root, struct node *temp){
+	if(temp->data < root->data && root->left){
+		search(root->left, temp);
+	}else if(temp->data < root->data && !root->left){
+		root->left = temp;
+	}else if(temp->data > root->data && root->right){
+		search(root->right, temp);
+	}else if(temp->data > root->data && !root->right){
+		root->right = temp;
+	}
+}
+
+int findMax(int a, int b){
+	return a > b ? a : b;
+}
+
+void addNode(int data){
+	struct node *temp = newNode(data);
+	if(root){
+		search(root, temp);
+	}else{
+		root = temp;
+	}
+}
+
+void inorder(struct node *root){
+	if(root){
+		inorder(root->left);
+		printf("%d ",root->data);
+		inorder(root->right);
+	}
+}
+
+int totalNodes(struct node *root){
+	int count = 0;
+	if(root){
+		count = count + 1;
+		count += totalNodes(root->left);
+		count += totalNodes(root->right);
+	}
+	return count;
+}
+
+int numLeaves(struct node *root){
+	if(!root){
+		return 0;
+	}
+	if(!root->left && !root->right){
+		return 1;
+	}
+	int left = numLeaves(root->left);
+	int right = numLeaves(root->right);
+
+	return left + right;
+}
+
+int fullNodes(struct node *root){
+	if(!root){
+		return 0;
+	}
+	if(root->left && root->right){
+		return 1;
+	}
+	int left = fullNodes(root->left);
+	int right = fullNodes(root->right);
+	return left + right;
+}
+
+int height(struct node *root){
+	if(!root){
+		return 0;
+	}
+	
+	int left = height(root->left);
+	int right = height(root->right);
+
+	return 1 + findMax(left, right);
+}
+
+int searchMin(struct node *root){
+	if(!root){
+		return 0;
+	}
+	while(root->left){
+		root = root->left;
+	}
+	return root->data;
+}
+
+int searchMax(struct node *root){
+	if(!root){
+		return 0;
+	}
+	while(root->right){
+		root = root->right;
+	}
+	return root->data;
+}
+
+int isComplete(struct node *root){
+	if(!root){
+		return 0;
+	}
+	if((!root->left && !root->right) || (root->left && root->right)){
+		return 1;
+	}
+	if((!root->left && root->right) || (root->left && !root->right) ){
+		return 0;
+	}
+	int left = isComplete(root->left);
+	int right = isComplete(root->right);
+
+	return left && right;
+}
+
+struct node *getInorderSuccessor(struct node *root){
+	if(root){
+		while(root->left){
+			root = root->left;
+		}
+		return root;
+	}
+	return NULL;
+}
+
+struct node *findAndDelete(struct node *root, int data){
+
+	if(!root){
+		return NULL;
+	}
+	if(data < root->data){
+		root->left = findAndDelete(root->left, data);
+	}else if(data > root->data) {
+		root->right = findAndDelete(root->right, data);
+	}else {
+
+		//if node has only one child or not child
+		if(!root->left){
+			struct node *temp = root->right;
+			free(root);
+			return temp;
+		}
+		if(!root->right){
+			struct node *temp = root->left;
+			free(root);
+			return temp;
+		}
+
+		//if it has two children
+		struct node *temp = getInorderSuccessor(root->right);
+
+		root->data = temp->data;
+
+		root->right = findAndDelete(root->right, temp->data);
+
+	}
+	return root;
+
+}
+
+int main(){
+	
+	int arr[] = {40,11,18,12,19,21,4,8};
+	int i;
+	int size =sizeof(arr)/sizeof(arr[0]);
+	for(i=0;i<size;i++) {
+		addNode(arr[i]);		
+	}
+	printf("inorder is...\n");
+	inorder(root);
+
+	printf("\n no of nodes are: %d\n", totalNodes(root));
+	printf("\n no of leaves are: %d\n", numLeaves(root));
+	printf("\n no of non-leaves are: %d\n", totalNodes(root) - numLeaves(root));
+	printf("\n no of full-nodes are: %d\n", fullNodes(root));
+	printf("\n height is: %d\n", height(root));
+	printf("\n min is: %d\n", searchMin(root));
+	printf("\n max is: %d\n", searchMax(root));
+	printf("\n tree is complete: %d\n", isComplete(root));
+
+	//delete a node
+	// printf("root of data is %d\n", root->data);
+	root = findAndDelete(root, 11);
+	printf("\ninorder is...\n");
+	inorder(root);
+
+	root = findAndDelete(root, 19);
+	printf("\ninorder is...\n");
+	inorder(root);
+
+	root = findAndDelete(root, 40);
+	printf("\ninorder is...\n");
+	inorder(root);
+
+	return 0;
+}