Day-10- BST predeccesor and successor algo + stack implementation

Author: mandliya

CMakeLists.txt

@@ -9,7 +9,7 @@ include_directories(".")
 file(GLOB SOURCES "./*/*.cpp")
 
 #compile flags
-set(CMAKE_CXX_FLAGS "-Wall -std=c++11")
+set(CMAKE_CXX_FLAGS "-Wall -std=c++11 -g -pedantic")
 
 foreach( sourcefile ${SOURCES} )
         get_filename_component( demo_name ${sourcefile} NAME_WE )

cracking_the_coding_interview_problems/1-2-old-reverseString.cpp

@@ -0,0 +1,108 @@
+/*** 
+ *     _  __                ___      _                                   
+ *     | |/ /___ ___ _ __   / __|__ _| |_ __                              
+ *     | ' </ -_) -_) '_ \ | (__/ _` | | '  \
+ *     |_|\_\___\___| .__/  \___\__,_|_|_|_|_|                            
+ *                  |_|                                                   
+ *                   _                                                    
+ *      __ _ _ _  __| |                                                   
+ *     / _` | ' \/ _` |                                                   
+ *     \__,_|_||_\__,_|                                                   
+ *                                                                        
+ *      _                          _   _              _ _   _             
+ *     | |   ___ __ _ _ _ _ _     /_\ | |__ _ ___ _ _(_) |_| |_  _ __  ___
+ *     | |__/ -_) _` | '_| ' \   / _ \| / _` / _ \ '_| |  _| ' \| '  \(_-<
+ *     |____\___\__,_|_| |_||_| /_/ \_\_\__, \___/_| |_|\__|_||_|_|_|_/__/
+ *                                      |___/                             
+ *     Yeah! Ravi let's do it! 
+ */
+
+#ifndef STACK_H
+#define STACK_H
+
+#include <iostream>
+#include <exception>
+#include <cstdint>
+
+namespace algo {
+    const uint32_t defaultCapacity = 500;
+
+    template <typename T = uintptr_t>
+    class Stack {
+        public:
+            Stack( uint32_t capacity = defaultCapacity )
+                : _capacity{ capacity }, _size{ 0 }, _elements{ new T[_capacity] }
+            {
+            }
+
+            Stack( const Stack & st )
+                : _capacity{ st.capacity }, _size{ st._size }, _elements{ new T[_capacity] }
+            {
+                for(uint32_t i = 0; i < _capacity; ++i) {
+                    _elements[i] = st._elements[i];
+                }
+            }
+
+            bool empty()
+            {
+                return (_size == 0 );
+            }
+
+            void pop()
+            {
+                if (empty())
+                    return;
+                _size--;
+            }
+
+            void push( const T & obj ) {
+                if ( _size == _capacity ) 
+                    throw stack_out_of_bound_exception;
+                _elements[_size++] = obj;
+            }
+            
+            const T & top()
+            {
+                if (empty())
+                    throw stack_empty_exception;
+                return _elements[_size - 1];
+            }
+
+            uint32_t size()
+            {
+                return _size;
+            }
+
+            void print(std::ostream & out = std::cout)
+            {
+                for (int i = _size - 1; i >= 0; --i) {
+                    out << _elements[i] << " ";
+                }
+                out << std::endl;
+            }
+
+           
+        private:
+            uint32_t _capacity;
+            uint32_t _size;
+            T * _elements;
+            Stack & operator=(const Stack & st);
+            
+            class StackEmptyException : public std::exception {
+                virtual const char *  what() const throw()
+                {
+                    return "Stack is empty";
+                }
+            } stack_empty_exception;
+
+            class StackOutofBoundException : public std::exception {
+                virtual const char * what() const throw()
+                {
+                    return "Stack Index out of bound";
+                }
+            } stack_out_of_bound_exception ;
+            
+    }; // end of class stack
+
+} // end of namespace algo
+#endif

include/stack.h

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <stack.h>
+
+int main()
+{
+    algo::Stack<double> st{10};
+    for ( int i = 0; i < 10; ++i) {
+        st.push( i );
+    }
+    st.print();
+    while (!st.empty()) {
+        std::cout << st.top() << " ";
+        st.pop();
+    }
+    while (st.size() > 0) {
+        std::cout << st.top() << " ";
+        st.pop();
+    }
+
+    std::cout << std::endl;
+    return 0;
+}

stack_problems/stackDemo.cpp

@@ -0,0 +1,105 @@
+/*
+ *  Goal : To find successor and predecessor ( if exists ) of a key in Binary Search Tree
+ *
+ */
+
+#include <iostream>
+#include <generic.h>
+
+/* Node of the tree */
+struct Node {
+    int data;
+    Node *left;
+    Node *right;
+};
+
+// Helper function to return a new node
+Node* newNode( const int & data )
+{
+    Node *node = new Node;
+    node->data = data;
+    node->left = node->right = nullptr;
+    return node;
+}
+
+//insert to a binary tree
+void insert( Node * & node, const int & data )
+{
+    if ( node == nullptr ) {
+        node = newNode(data);
+        return;
+    }
+    
+    if ( data < node->data ) {
+        insert( node->left, data);
+    } else {
+        insert( node->right, data);
+    }
+}
+
+// print inorder traversal of the tree
+void inorder( Node * node)
+{
+    if ( node != nullptr )
+    {
+        inorder(node->left);
+        std::cout << node->data << " ";
+        inorder(node->right);
+    }
+}
+
+void predecessorSuccessor( Node *node, Node * &pred, Node * & succ, int key )
+{
+    if ( node == nullptr )
+        return;
+
+    if ( node->data == key )
+    {
+        if (node->left) {
+            Node *temp = node->left;
+            while (temp->right)
+                temp = temp->right;
+            pred = temp;
+        }
+
+        if (node->right) {
+            Node * temp = node->right;
+            while (temp->left)
+                temp = temp->left;
+            succ = temp;
+        }
+    } else if ( key < node->data ) {
+        succ = node;
+        predecessorSuccessor( node->left, pred, succ, key );
+    } else {
+        pred = node;
+        predecessorSuccessor( node->right, pred, succ, key );
+    }
+}
+
+int main()
+{
+    Node * root = nullptr;
+    int key = 20;
+    for ( int i = 0; i < 10; ++i) {
+        insert( root, algo::random_range(10, 40));
+    }
+
+    Node *pred = nullptr, *succ = nullptr;
+    //print the inorder of created tree
+    std::cout << "Tree's inorder traversal:\n";
+    inorder(root);
+    std::cout << "Finding predecessor and successor of key " << key << " (if exists):\n";
+    predecessorSuccessor(root, pred, succ, key);
+    if (pred != nullptr ) {
+        std::cout << "Predeccessor is " << pred->data << std::endl;
+    } else {
+        std::cout << "No predecessor\n";
+    }
+    if (succ != nullptr) {
+        std::cout << "Successor is " << succ->data << std::endl;
+    } else {
+        std::cout << "No successor\n";
+    }
+    return 0;
+}