Problems related to the BT

Author: sammijss

Array/Array.hpp

@@ -0,0 +1,23 @@
+#ifndef _ARRAY_H_
+#define _ARRAY_H_
+
+#include<iostream>
+#include<algorithm>
+/*
+ * PRINT API
+ */
+#define PRINT_ARRAY(array, size)\
+    std::for_each(array, array+size, [](int a){ std::cout <<a <<" "; });\
+    std::cout <<std::endl;
+
+/*
+ * FIND APIs
+ */
+void find_k_smallest_elements_using_modified_bubble_sort(int array[], int size, int k);
+void find_k_smallest_elements_using_sorting(int array[], int size, int k);
+
+int  find_smallest_missing_number(int array[], int size);
+
+void find_all_triplets_with_sum_zero(int array[], int size);
+
+#endif

Array/Find.cpp

@@ -0,0 +1,100 @@
+#include<climits>
+#include"Array.hpp"
+
+/*
+ * Find the k largest (or smallest) elements in an array 
+ * Time  Complexity: O(n*k)
+ * Space Complexity: O(1)
+ */
+void find_k_smallest_elements_using_modified_bubble_sort(int array[], int size, int k)
+{
+    PRINT_ARRAY(array, size);
+    for (int i=0; i<k; i++) {
+        for (int j=0; j<size-1-i; j++) {
+            if (array[j] < array[j+1]) {
+                std::swap(array[j], array[j+1]);
+            }
+        }
+    }
+
+    for (int i=1; i<=k; i++) {
+        std::cout <<array[size-i] <<" ";
+    }
+    std::cout <<std::endl;
+}
+
+/*
+ * Find the k largest (or smallest) elements in an array 
+ * Time  Complexity: O(n(logn))
+ * Space Complexity: O(1)
+ */
+void find_k_smallest_elements_using_sorting(int array[], int size, int k)
+{
+    PRINT_ARRAY(array, size);
+    std::sort(array, array+size);   //n*log2(n)
+    PRINT_ARRAY(array, k);
+}
+
+//TODO
+/*
+ * Given a sorted array of n distinct integers where each integer is in the range from 0 to m-1 and m > n.
+ *
+ * Perform the linear search and compare the value of the array with index if both will not match then value of the index will be our smallest missing number
+ * Time  Complexity: O(n))
+ * Space Complexity: O(1)
+ *
+ * Perform the binary search and compare the value of the array with index if both will not match then value of the index will be our smallest missing number
+ * Time  Complexity: O(logn))
+ * Space Complexity: O(1)
+ */
+int find_smallest_missing_number(int array[], int size)
+{
+    int l = 0;
+    int r = size - 1;
+    while(l < r) {
+        int m = (l + r)/2;
+        std::cout <<"m: " <<m <<std::endl;
+        if (array[m] != m) {
+            std::cout <<"Smallest missing number: " <<m <<std::endl;
+            return(m);
+        } else if (array[m] > m) {
+            l = m + 1;
+        } else {
+            r = m - 1;
+        }
+    }
+    std::cout <<"Smallest missing number is not found" <<std::endl;
+    return(INT_MIN);
+}
+
+/*
+ * We can use three loops to find all triplets equal to zero
+ * Time  Complexity: O(n3))
+ * Space Complexity: O(1)
+ *
+ * We can optimize the solution by sorting the array and using two loops
+ * Time  Complexity: O(n2))
+ * Space Complexity: O(1)
+ */
+void find_all_triplets_with_sum_zero(int array[], int size)
+{
+    PRINT_ARRAY(array, size);
+    std::sort(array, array+size);   //n*log2(n)
+
+    for (int i=0; i<size-2; i++) {
+        int x = array[i];
+        int l = i+1;
+        int r = size-1;
+        while(l < r) {
+            if ((x + array[l] + array[r]) == 0) {
+                std::cout <<"(" <<x <<" + " <<array[l] <<" + " <<array[r] <<")" <<std::endl;
+                l++;
+                r--;
+            } else if ((x + array[l] + array[r]) < 0) {
+                l++;
+            } else {
+                r--;
+            }
+        }
+    }
+}

Array/Main.cpp

@@ -0,0 +1,18 @@
+#include"Array.hpp"
+
+int main()
+{
+    int array[] = {1, 7, 2, -1, 2, 3, 0, 6, 5, 4};
+    find_k_smallest_elements_using_modified_bubble_sort(array, sizeof(array)/sizeof(int), 3);
+
+    int array2[] = {1, 7, 2, -1, 2, 3, 0, 6, 5, 4};
+    find_k_smallest_elements_using_sorting(array2, sizeof(array2)/sizeof(int), 3);
+
+    int array3[] = {0, -1, 2, -3, 1, -4, 5};
+    find_all_triplets_with_sum_zero(array3, sizeof(array3)/sizeof(int));
+
+    int array4[] = {0, 1, 2, 6, 9};
+    find_smallest_missing_number(array4, sizeof(array4)/sizeof(int));
+
+    return(0);
+}

Array/Makefile

@@ -0,0 +1,27 @@
+# define compiler
+COMPILER=g++
+
+# define compiler flags
+FLAGS=-std=c++11 -g -Wall
+
+# define executable target
+OBJECTS=Main.o\
+        Find.o
+
+BINARY=Array
+
+all: clean $(BINARY)
+    
+Array: $(OBJECTS) 
+	$(COMPILER) $(FLAGS) $(OBJECTS) -o $(BINARY)
+
+Main.o:
+	$(COMPILER) -c $(FLAGS) Main.cpp
+
+Find.o:
+	$(COMPILER) -c $(FLAGS) Find.cpp
+
+clean:
+	rm -f $(BINARY) *.o
+
+.PHONY: clean

BST/BST.cpp

@@ -0,0 +1,17 @@
+#include <stack> 
+#include "BST.hpp" 
+
+Node* AddNode(Node* root, int data) {
+    if (!root) {
+        return (new Node(data));
+    }
+    
+    if (root->data > data) {
+            root->left = AddNode(root->left, data);
+    }
+    else {
+            root->right = AddNode(root->right, data);
+    }
+    return root;
+}
+

BST/BST.hpp

@@ -0,0 +1,22 @@
+#ifndef _BST_H_
+#define _BST_H_
+
+#include <iostream>
+
+struct Node {
+    int data;
+    Node* left;
+    Node* right;
+
+    Node(int data) {
+        this->data = data;
+        this->left = this->right = NULL;
+    }
+};
+
+/*
+ * APIs
+ */
+Node* AddNode(Node* root, int data);
+
+#endif

BST/Main.cpp

@@ -0,0 +1,15 @@
+#include "BST.hpp"
+
+int main()
+{
+    Node* root = NULL;
+    root = AddNode(root, 50);
+    AddNode(root, 30);
+    AddNode(root, 20);
+    AddNode(root, 40);
+    AddNode(root, 70);
+    AddNode(root, 60);
+    AddNode(root, 80);
+
+    return(0);
+}

BST/Makefile

@@ -0,0 +1,27 @@
+# define compiler
+COMPILER=g++
+
+# define compiler flags
+FLAGS=-std=c++11 -g -Wall
+
+# define executable target
+OBJECTS=Main.o\
+        BST.o
+
+BINARY=BST
+
+all: clean $(BINARY)
+    
+BST: $(OBJECTS) 
+	$(COMPILER) $(FLAGS) $(OBJECTS) -o $(BINARY) 
+
+Main.o:
+	$(COMPILER) -c $(FLAGS) Main.cpp
+
+BST.o:
+	$(COMPILER) -c $(FLAGS) BST.cpp
+
+clean:
+	rm -f $(BINARY) *.o
+
+.PHONY: clean