Merge branch 'ds-ops' of github.com:foo290/C-Plus-Plus into ds-ops

operations_on_datastructures/inorder_successor_of_bst.cpp

@@ -1,29 +1,34 @@
 /**
  * @file
  * @brief An implementation for finding the [Inorder successor of a binary
- * search tree](https://www.youtube.com/watch?v=5cPbNCrdotA&t=904s) Inorder
+ * search tree](https://www.youtube.com/watch?v=5cPbNCrdotA) Inorder
  * successor of a node is the next node in Inorder traversal of the Binary Tree.
  * Inorder Successor is NULL for the last node in Inorder traversal.
  * @details
  * ### Case 1: The given node has the right node/subtree
  *
- *      In this case the left most deepest node in the right subtree will come just
+ *      * In this case, the left-most deepest node in the right subtree will
- *      after the given node as we go to left deep in inorder.
+ * come just after the given node as we go to left deep in inorder.
  *      - Go deep to left most node in right subtree.
- *        OR, we can also say in case if BST, find the minimum of the subtree for a given node.
+ *        OR, we can also say in case if BST, find the minimum of the subtree
+ * for a given node.
  *
  * ### Case 2: The given node does not have a right node/subtree
  *
  * #### Method 1: Use parent pointer (store the address of parent nodes)
- *      * If a node does not have the right subtree, and we already visited the node itself,
+ *      * If a node does not have the right subtree, and we already visited the
- *      then the next node will be its parent node according to inorder traversal,
+ * node itself, then the next node will be its parent node according to inorder
- *      and if we are going to parent from left, then the parent would be unvisited.
+ * traversal, and if we are going to parent from left, then the parent would be
- *      * In other words, go to the nearest ancestor for which given node would be in left subtree.
+ * unvisited.
+ *      * In other words, go to the nearest ancestor for which given node would
+ * be in left subtree.
  *
  * #### Method 2: Search from the root node
- *      * In case if there is no link from a child node to the parent node, we need to walk down the tree starting
+ *      * In case if there is no link from a child node to the parent node, we
- *      from the root node to the given node, by doing so, we are visiting every ancestor of the given node.
+ * need to walk down the tree starting from the root node to the given node, by
- *      * In order successor would be the deepest node in this path for which given node is in left subtree.
+ * doing so, we are visiting every ancestor of the given node.
+ *      * In order successor would be the deepest node in this path for which
+ * given node is in left subtree.
  *
  * @author [Nitin Sharma](https://github.com/foo290)
  * */
@@ -43,30 +48,30 @@ namespace operations_on_datastructures {
  * @brief Functions for the [Inorder successor of a binary search
  * tree](https://www.youtube.com/watch?v=5cPbNCrdotA) implementation
  */
-    namespace inorder_traversal_of_bst {
+namespace inorder_traversal_of_bst {
 
 /**
  * @brief A Node structure representing a single node in BST
  */
-        class Node {
+class Node {
  public:
     int64_t data;  ///< The key/value of the node
     Node *left;    ///< Pointer to Left child
     Node *right;   ///< Pointer to right child
-        };
+};
 
 /**
  * @brief Allocates a new node in heap for given data and returns it's pointer.
  * @param data Data for the node.
  * @returns A pointer to the newly allocated Node.
  * */
-        Node *makeNode(int64_t data) {
+Node *makeNode(int64_t data) {
     Node *node = new Node();
     node->data = data;      ///< setting data for node
     node->left = nullptr;   ///< setting left child as null
     node->right = nullptr;  ///< setting right child as null
     return node;
-        }
+}
 
 /**
  * @brief Inserts the given data in BST while maintaining the properties of BST.
@@ -74,7 +79,7 @@ namespace operations_on_datastructures {
  * @param data Data to be inserted.
  * @returns Node* Pointer to the root node.
  * */
-        Node *Insert(Node *root, int64_t data) {
+Node *Insert(Node *root, int64_t data) {
     if (root == nullptr) {
         root = makeNode(data);
     } else if (data <= root->data) {
@@ -83,7 +88,7 @@ namespace operations_on_datastructures {
         root->right = Insert(root->right, data);
     }
     return root;
-        }
+}
 
 /**
  * @brief Searches the given data in BST and returns the pointer to the node
@@ -92,28 +97,28 @@ namespace operations_on_datastructures {
  * @param data Data to be Searched.
  * @returns Node* pointer to the found node
  * */
-        Node *getNode(Node *root, int64_t data) {
+Node *getNode(Node *root, int64_t data) {
     if (root == nullptr) {
         return nullptr;
     } else if (root->data == data) {
         return root;  /// Node found!
     } else if (data > root->data) {
-                /// Traverse right subtree recursively as the given data is greater than the data in root node,
+        /// Traverse right subtree recursively as the given data is greater than
-                /// data must be present in right subtree.
+        /// the data in root node, data must be present in right subtree.
         return getNode(root->right, data);
     } else {
-                /// Traverse left subtree recursively as the given data is less than the data in root node,
+        /// Traverse left subtree recursively as the given data is less than the
-                /// data must be present in left subtree.
+        /// data in root node, data must be present in left subtree.
         return getNode(root->left, data);
     }
-        }
+}
 
 /**
  * @brief Finds and return the minimum node in BST.
  * @param root A pointer to root node.
  * @returns Node* Pointer to the found node
  * */
-        Node *findMinNode(Node *root) {
+Node *findMinNode(Node *root) {
     if (root == nullptr) {
         return root;
     }
@@ -121,14 +126,14 @@ namespace operations_on_datastructures {
         root = root->left;
     }
     return root;
-        }
+}
 
 /**
  * @brief Prints the BST in inorder traversal using recursion.
  * @param root A pointer to the root node of the BST.
  * @returns void
  * */
-        void printInorder(Node *root) {
+void printInorder(Node *root) {
     if (root == nullptr) {
         return;
     }
@@ -136,7 +141,7 @@ namespace operations_on_datastructures {
     printInorder(root->left);  /// recursive call to left subtree
     std::cout << root->data << " ";
     printInorder(root->right);  /// recursive call to right subtree
-        }
+}
 
 /**
  * @brief This function is used in test cases to quickly create BST containing
@@ -147,17 +152,18 @@ namespace operations_on_datastructures {
  * inserted as nodes in BST.
  * @returns Node pointer to the root node.
  * */
-        Node *makeBST(Node *root, const std::vector<int64_t> &data) {
+Node *makeBST(Node *root, const std::vector<int64_t> &data) {
     for (int64_t values : data) {
         root = Insert(root, values);
     }
     return root;
-        }
+}
 
 /**
- * @brief Inorder successor of a node is the next node in inorder traversal of the Binary Tree.
+ * @brief Inorder successor of a node is the next node in inorder traversal of
- * This function takes the root node and the data of the node for which we have to find the inorder successor, and
+ * the Binary Tree. This function takes the root node and the data of the node
- * returns the inorder successor node.
+ * for which we have to find the inorder successor, and returns the inorder
+ * successor node.
  * @details Search from the root node as we need to walk the tree starting from
  * the root node to the given node, by doing so, we are visiting every ancestor
  * of the given node. In order successor would be the deepest node in this path
@@ -167,7 +173,7 @@ namespace operations_on_datastructures {
  * successor.
  * @returns Node pointer to the inorder successor node.
  * */
-        Node *getInorderSuccessor(Node *root, int64_t data) {
+Node *getInorderSuccessor(Node *root, int64_t data) {
     Node *current = getNode(root, data);
     if (current == nullptr) {
         return nullptr;
@@ -193,31 +199,30 @@ namespace operations_on_datastructures {
         }
         return successor;  // Nodes with maximum vales will not have a successor
     }
-        }
+}
 
-        /**
+/**
-         * @brief This function clears the memory allocated to entire tree recursively. Its just for clean up the 
+ * @brief This function clears the memory allocated to entire tree recursively.
-         * memory and not relevant to the actual topic.
+ * Its just for clean up the memory and not relevant to the actual topic.
  * @param root Root node of the tree.
  * @returns void
  * */
-        void deallocate (Node* rootNode){
+void deallocate(Node *rootNode) {
-            if (rootNode == nullptr) return;
+    if (rootNode == nullptr)
+        return;
     deallocate(rootNode->left);
     deallocate(rootNode->right);
-            delete(rootNode);
+    delete (rootNode);
-        }
+}
 
-    }  // namespace inorder_traversal_of_bst
+}  // namespace inorder_traversal_of_bst
 }  // namespace operations_on_datastructures
 
-
-
 /**
  * @brief class encapsulating the necessary test cases
  */
 class TestCases {
-private:
+ private:
     /**
      * @brief A function to print given message on console.
      * @tparam T Type of the given message.
@@ -229,7 +234,7 @@ private:
         std::cout << "[TESTS] : ---> " << msg << std::endl;
     }
 
-public:
+ public:
     /**
      * @brief Executes test cases
      * @returns void
@@ -283,7 +288,8 @@ public:
         assert(inorderSuccessor == expectedOutput);
         log("Assertion check passed!");
 
-        operations_on_datastructures::inorder_traversal_of_bst::deallocate(root);  /// memory cleanup!
+        operations_on_datastructures::inorder_traversal_of_bst::deallocate(
+            root);  /// memory cleanup!
 
         log("[PASS] : TEST CASE 1 PASS!");
         log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
@@ -323,7 +329,8 @@ public:
         assert(inorderSuccessor->data == expectedOutput);
         log("Assertion check passed!");
 
-        operations_on_datastructures::inorder_traversal_of_bst::deallocate(root); /// memory cleanup!
+        operations_on_datastructures::inorder_traversal_of_bst::deallocate(
+            root);  /// memory cleanup!
 
         log("[PASS] : TEST CASE 2 PASS!");
         log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
@@ -364,7 +371,8 @@ public:
         assert(inorderSuccessor->data == expectedOutput);
         log("Assertion check passed!");
 
-        operations_on_datastructures::inorder_traversal_of_bst::deallocate(root);  /// memory cleanup!
+        operations_on_datastructures::inorder_traversal_of_bst::deallocate(
+            root);  /// memory cleanup!
 
         log("[PASS] : TEST CASE 3 PASS!");
         log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
@@ -411,7 +419,7 @@ int main(int argc, char *argv[]) {
     } else {
         std::cout << "Target element is : " << targetElement << std::endl;
         std::cout << "Inorder successor for target element is : "
-                  << inorderSuccessor->data;
+                  << inorderSuccessor->data << std::endl;
     }
 
     deallocate(root);  /// memory cleanup!