From 80772024d3cc431c60442191edafcb2be9941201 Mon Sep 17 00:00:00 2001 From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Date: Tue, 13 Jul 2021 02:29:14 +0000 Subject: [PATCH 1/5] clang-format and clang-tidy fixes for f1b83198 --- .../inorder_successor_of_bst.cpp | 266 +++++++++--------- 1 file changed, 136 insertions(+), 130 deletions(-) diff --git a/operations_on_datastructures/inorder_successor_of_bst.cpp b/operations_on_datastructures/inorder_successor_of_bst.cpp index ffbbd9797..6c420dfa0 100644 --- a/operations_on_datastructures/inorder_successor_of_bst.cpp +++ b/operations_on_datastructures/inorder_successor_of_bst.cpp @@ -7,23 +7,28 @@ * @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 - * after the given node as we go to left deep in inorder. + * In this case the left most deepest node in the right subtree will 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, - * then the next node will be its parent node according to inorder traversal, - * and if we are going to parent from left, then the parent would be unvisited. - * * In other words, go to the nearest ancestor for which given node would be in left subtree. + * * If a node does not have the right subtree, and we already visited the + * node itself, then the next node will be its parent node according to inorder + * traversal, and if we are going to parent from left, then the parent would be + * 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 - * 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 for which given node is in left subtree. + * * In case if there is no link from a child node to the parent node, we + * need to walk down 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 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 { - public: - int64_t data; ///< The key/value of the node - Node *left; ///< Pointer to Left child - Node *right; ///< Pointer to right child - }; +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 *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; - } +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,16 +79,16 @@ namespace operations_on_datastructures { * @param data Data to be inserted. * @returns Node* Pointer to the root node. * */ - Node *Insert(Node *root, int64_t data) { - if (root == nullptr) { - root = makeNode(data); - } else if (data <= root->data) { - root->left = Insert(root->left, data); - } else { - root->right = Insert(root->right, data); - } - return root; - } +Node *Insert(Node *root, int64_t data) { + if (root == nullptr) { + root = makeNode(data); + } else if (data <= root->data) { + root->left = Insert(root->left, data); + } else { + root->right = Insert(root->right, data); + } + return root; +} /** * @brief Searches the given data in BST and returns the pointer to the node @@ -92,51 +97,51 @@ namespace operations_on_datastructures { * @param data Data to be Searched. * @returns Node* pointer to the found node * */ - 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, - /// 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, - /// data must be present in left subtree. - return getNode(root->left, 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, 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, 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) { - if (root == nullptr) { - return root; - } - while (root->left != nullptr) { - root = root->left; - } - return root; - } +Node *findMinNode(Node *root) { + if (root == nullptr) { + return root; + } + while (root->left != nullptr) { + 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) { - if (root == nullptr) { - return; - } +void printInorder(Node *root) { + if (root == nullptr) { + return; + } - printInorder(root->left); /// recursive call to left subtree - std::cout << root->data << " "; - printInorder(root->right); /// recursive call to right subtree - } + 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 &data) { - for (int64_t values : data) { - root = Insert(root, values); - } - return root; - } +Node *makeBST(Node *root, const std::vector &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. - * This function takes the root node and the data of the node for which we have to find the inorder successor, and - * returns the inorder successor node. + * @brief Inorder successor of a node is the next node in inorder traversal of + * the Binary Tree. This function takes the root node and the data of the 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,33 +173,33 @@ namespace operations_on_datastructures { * successor. * @returns Node pointer to the inorder successor node. * */ - Node *getInorderSuccessor(Node *root, int64_t data) { - Node *current = getNode(root, data); - if (current == nullptr) { - return nullptr; - } +Node *getInorderSuccessor(Node *root, int64_t data) { + Node *current = getNode(root, data); + if (current == nullptr) { + return nullptr; + } - // Case - 1 - if (current->right != nullptr) { - return findMinNode(current->right); - } - // case - 2 - else { - Node *successor = nullptr; - Node *ancestor = root; + // Case - 1 + if (current->right != nullptr) { + return findMinNode(current->right); + } + // case - 2 + else { + Node *successor = nullptr; + Node *ancestor = root; - while (ancestor != current && ancestor != nullptr) { - // This means my current node is in left of the root node - if (current->data < ancestor->data) { - successor = ancestor; - ancestor = ancestor->left; // keep going left - } else { - ancestor = ancestor->right; - } - } - return successor; // Nodes with maximum vales will not have a successor + while (ancestor != current && ancestor != nullptr) { + // This means my current node is in left of the root node + if (current->data < ancestor->data) { + successor = ancestor; + ancestor = ancestor->left; // keep going left + } else { + ancestor = ancestor->right; } } + return successor; // Nodes with maximum vales will not have a successor + } +} } // namespace inorder_traversal_of_bst } // namespace operations_on_datastructures @@ -201,7 +207,7 @@ 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. @@ -213,7 +219,7 @@ private: std::cout << "[TESTS] : ---> " << msg << std::endl; } -public: + public: /** * @brief Executes test cases * @returns void @@ -236,7 +242,7 @@ public: * */ void testCase_1() { const operations_on_datastructures::inorder_traversal_of_bst::Node - *expectedOutput = nullptr; ///< Expected output of this test + *expectedOutput = nullptr; ///< Expected output of this test log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"); log("This is test case 1 : "); @@ -245,23 +251,23 @@ public: "BST, Output will be nullptr."); operations_on_datastructures::inorder_traversal_of_bst::Node *root = - nullptr; + nullptr; std::vector node_data{ - 20, 3, 5, 6, 2, 23, 45, 78, 21}; ///< Data to make nodes in BST + 20, 3, 5, 6, 2, 23, 45, 78, 21}; ///< Data to make nodes in BST root = operations_on_datastructures::inorder_traversal_of_bst::makeBST( - root, - node_data); ///< Adding nodes to BST + root, + node_data); ///< Adding nodes to BST std::cout << "Inorder sequence is : "; operations_on_datastructures::inorder_traversal_of_bst::printInorder( - root); ///< Printing inorder to cross-verify. + root); ///< Printing inorder to cross-verify. std::cout << std::endl; operations_on_datastructures::inorder_traversal_of_bst::Node - *inorderSuccessor = operations_on_datastructures:: - inorder_traversal_of_bst::getInorderSuccessor( - root, 78); ///< The inorder successor node for given data + *inorderSuccessor = operations_on_datastructures:: + inorder_traversal_of_bst::getInorderSuccessor( + root, 78); ///< The inorder successor node for given data log("Checking assert expression..."); assert(inorderSuccessor == expectedOutput); @@ -286,23 +292,23 @@ public: log("This is test case 2 : "); operations_on_datastructures::inorder_traversal_of_bst::Node *root = - nullptr; + nullptr; std::vector node_data{ - 20, 3, 5, 6, 2, 23, 45, 78, 21}; ///< Data to make nodes in BST + 20, 3, 5, 6, 2, 23, 45, 78, 21}; ///< Data to make nodes in BST root = operations_on_datastructures::inorder_traversal_of_bst::makeBST( - root, - node_data); ///< Adding nodes to BST + root, + node_data); ///< Adding nodes to BST std::cout << "Inorder sequence is : "; operations_on_datastructures::inorder_traversal_of_bst::printInorder( - root); ///< Printing inorder to cross-verify. + root); ///< Printing inorder to cross-verify. std::cout << std::endl; operations_on_datastructures::inorder_traversal_of_bst::Node - *inorderSuccessor = operations_on_datastructures:: - inorder_traversal_of_bst::getInorderSuccessor( - root, 20); ///< The inorder successor node for given data + *inorderSuccessor = operations_on_datastructures:: + inorder_traversal_of_bst::getInorderSuccessor( + root, 20); ///< The inorder successor node for given data log("Checking assert expression..."); assert(inorderSuccessor->data == expectedOutput); @@ -327,24 +333,24 @@ public: log("This is test case 3 : "); operations_on_datastructures::inorder_traversal_of_bst::Node *root = - nullptr; + nullptr; std::vector node_data{ - 89, 67, 32, 56, 90, 123, 120, - 110, 115, 6, 78, 7, 10}; ///< Data to make nodes in BST + 89, 67, 32, 56, 90, 123, 120, + 110, 115, 6, 78, 7, 10}; ///< Data to make nodes in BST root = operations_on_datastructures::inorder_traversal_of_bst::makeBST( - root, - node_data); ///< Adding nodes to BST + root, + node_data); ///< Adding nodes to BST std::cout << "Inorder sequence is : "; operations_on_datastructures::inorder_traversal_of_bst::printInorder( - root); ///< Printing inorder to cross-verify. + root); ///< Printing inorder to cross-verify. std::cout << std::endl; operations_on_datastructures::inorder_traversal_of_bst::Node - *inorderSuccessor = operations_on_datastructures:: - inorder_traversal_of_bst::getInorderSuccessor( - root, 90); ///< The inorder successor node for given data + *inorderSuccessor = operations_on_datastructures:: + inorder_traversal_of_bst::getInorderSuccessor( + root, 90); ///< The inorder successor node for given data log("Checking assert expression..."); assert(inorderSuccessor->data == expectedOutput); @@ -377,17 +383,17 @@ int main(int argc, char *argv[]) { test(); // run self-test implementations operations_on_datastructures::inorder_traversal_of_bst::Node *root = - nullptr; ///< root node of the bst + nullptr; ///< root node of the bst std::vector node_data{3, 4, 5, 89, 1, 2}; ///< Data to add nodes in BST int64_t targetElement = 4; ///< An element to find inorder successor for. root = operations_on_datastructures::inorder_traversal_of_bst::makeBST( - root, node_data); ///< Making BST + root, node_data); ///< Making BST operations_on_datastructures::inorder_traversal_of_bst::Node - *inorderSuccessor = operations_on_datastructures:: - inorder_traversal_of_bst::getInorderSuccessor(root, targetElement); + *inorderSuccessor = operations_on_datastructures:: + inorder_traversal_of_bst::getInorderSuccessor(root, targetElement); std::cout << "In-order sequence is : "; operations_on_datastructures::inorder_traversal_of_bst::printInorder(root); From 420a4ec193a686805bf969c3e01f819ebe14af90 Mon Sep 17 00:00:00 2001 From: Nitin Sharma <32377892+foo290@users.noreply.github.com> Date: Wed, 14 Jul 2021 09:23:16 +0530 Subject: [PATCH 2/5] Update operations_on_datastructures/inorder_successor_of_bst.cpp Co-authored-by: David Leal --- operations_on_datastructures/inorder_successor_of_bst.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/operations_on_datastructures/inorder_successor_of_bst.cpp b/operations_on_datastructures/inorder_successor_of_bst.cpp index 6c420dfa0..7c0fc3d7c 100644 --- a/operations_on_datastructures/inorder_successor_of_bst.cpp +++ b/operations_on_datastructures/inorder_successor_of_bst.cpp @@ -7,7 +7,7 @@ * @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 + * * In this case, the left-most deepest node in the right subtree will 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 From b1b82086b5d0f008b96ad4e7831b22bfbeedb40d Mon Sep 17 00:00:00 2001 From: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Date: Wed, 14 Jul 2021 03:53:59 +0000 Subject: [PATCH 3/5] clang-format and clang-tidy fixes for 420a4ec1 --- operations_on_datastructures/inorder_successor_of_bst.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/operations_on_datastructures/inorder_successor_of_bst.cpp b/operations_on_datastructures/inorder_successor_of_bst.cpp index 7c0fc3d7c..b5f454f30 100644 --- a/operations_on_datastructures/inorder_successor_of_bst.cpp +++ b/operations_on_datastructures/inorder_successor_of_bst.cpp @@ -7,8 +7,8 @@ * @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 after the given node as we go to left deep in inorder. + * * In this case, the left-most deepest node in the right subtree will + * 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. From 2d738ecf1cad55ab427a6426ce7ef99811b723ad Mon Sep 17 00:00:00 2001 From: David Leal Date: Wed, 14 Jul 2021 00:26:03 -0500 Subject: [PATCH 4/5] Apply suggestions from code review --- operations_on_datastructures/inorder_successor_of_bst.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/operations_on_datastructures/inorder_successor_of_bst.cpp b/operations_on_datastructures/inorder_successor_of_bst.cpp index b5f454f30..8be1e385f 100644 --- a/operations_on_datastructures/inorder_successor_of_bst.cpp +++ b/operations_on_datastructures/inorder_successor_of_bst.cpp @@ -404,7 +404,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; } delete (inorderSuccessor); From ff2acc546409a8616b727b3ac2370915d5e34e6d Mon Sep 17 00:00:00 2001 From: David Leal Date: Wed, 14 Jul 2021 19:53:56 -0500 Subject: [PATCH 5/5] fix: Apply suggestions from code review --- operations_on_datastructures/inorder_successor_of_bst.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/operations_on_datastructures/inorder_successor_of_bst.cpp b/operations_on_datastructures/inorder_successor_of_bst.cpp index 8be1e385f..0397a2382 100644 --- a/operations_on_datastructures/inorder_successor_of_bst.cpp +++ b/operations_on_datastructures/inorder_successor_of_bst.cpp @@ -1,7 +1,7 @@ /** * @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