refactor(cpp): update 'BinarySearchTree', adding other operations...

...like 'delete', 'find min', 'find max'.

In addition to that, in this version, object oriented code is present.
`BinarySearchTree` is a class, and it has behaviour that operates on the state.

Author: hmigl

src/cpp/BinarySearchTree.cpp

@@ -3,124 +3,244 @@
 /*
  * Structure for a binary tree node
  */
-
 struct Node {
-    int data;       // data value stored in the node
-    Node* left;     // pointer to the left child node
-    Node* right;    // pointer to the right child node
-
-    /**
-     * Constructor to create a new node with the given data.
-     * 
-     * @param value the data value for the new node.
-     */
-
-    Node(int value) : data(value), left(nullptr), right(nullptr) {}
+  int data;     ///< The integer data value stored in the node.
+  Node *left;   ///< Pointer to the left child node.
+  Node *right;  ///< Pointer to the right child node.
+
+  /**
+   * Constructor to create a new node with the given data.
+   *
+   * @param value the data value for the new node.
+   */
+  Node(int data) : data(data), left(nullptr), right(nullptr) {}
 };
 
+class BinarySearchTree {
+ public:
+  BinarySearchTree() : root(nullptr) {}
 
+  Node *find(int x) const { return _find(this->root, x); }
 
-/**
- * Function to insert a new node into the binary tree.
- *
- * @param root  pointer to the root of the binary tree.
- * @param value the value to be inserted.
- *
- * @return pointer to the root of the modified binary tree.
- */
-
-Node* insert(Node* root, int value) {
-    if (root == nullptr) {
-        return new Node(value);
-    }
-    if (value < root->data) {
-        root->left = insert(root->left, value);
-    }
-    else if (value > root->data) {
-        root->right = insert(root->right, value);
-    }
-    return root;
-}
-
-
+  void insert(int x) { _insert(&(this->root), x); }
 
-/**
- * Function for an in-order traversal of the binary tree (Left-Root-Right).
- *
- * @param root pointer to the root of the binary tree.
- */
+  void deleteNode(int x) { _delete(&(this->root), x); }
 
-void inOrderTraversal(Node* root) {
-    if (root == nullptr) {
-        return;
-    }
-    inOrderTraversal(root->left);
-    std::cout << root->data << " ";
-    inOrderTraversal(root->right);
-}
+  void preorderTraversal() const { _printPreorder(this->root); }
 
+  void inorderTraversal() const { _printInorder(this->root); }
 
+  void postorderTraversal() const { _printPostorder(this->root); }
 
-/**
- * Function for a pre-order traversal of the binary tree (Root-Left-Right).
- *
- * @param root pointer to the root of the binary tree.
- */
+ private:
+  Node *root;
 
-void preOrderTraversal(Node* root) {
-    if (root == nullptr) {
-        return;
+  /**
+   * @brief Find a node with a specific value in the binary search tree.
+   *
+   * This function searches the binary search tree starting from the given root
+   * node for a node that contains the specified value `x`. If a node with the
+   * value `x` is found, a pointer to that node is returned. If no such node
+   * exists in the tree, the function returns `nullptr`.
+   *
+   * @param root A pointer to the root node of the binary search tree.
+   * @param x The value to search for in the tree.
+   * @return A pointer to the node containing the value `x`, or `nullptr` if not
+   * found.
+   */
+  Node *_find(Node *root, int x) const {
+    if (!root || root->data == x) {
+      return root;
     }
-    std::cout << root->data << " ";
-    preOrderTraversal(root->left);
-    preOrderTraversal(root->right);
-}
-
-
-
-/**
- * Function for a post-order traversal of the binary tree (Left-Right-Root).
- *
- * @param root pointer to the root of the binary tree.
- */
-
-void postOrderTraversal(Node* root) {
-    if (root == nullptr) {
-        return;
+    if (x < root->data) {
+      return _find(root->left, x);
+    } else {
+      return _find(root->right, x);
+    }
+  }
+
+  /**
+   * @brief Inserts a new node with the specified value into the binary search
+   * tree.
+   *
+   * This function inserts a new node containing the value `x` into the binary
+   * search tree. It traverses the tree starting from the given root node
+   * (passed as a pointer to a pointer) and inserts the new node at the
+   * appropriate position based on the value `x`.
+   *
+   * @param root A pointer to a pointer to the root node of the binary search
+   * tree.
+   * @param x The value to insert into the tree.
+   * @return A pointer to the updated root node of the tree after the insertion.
+   */
+  Node *_insert(Node **root, int x) {
+    if (!(*root)) {
+      *root = new Node(x);
+    } else if (x <= (*root)->data) {
+      (*root)->left = _insert(&((*root)->left), x);
+    } else {
+      (*root)->right = _insert(&((*root)->right), x);
+    }
+    return *root;
+  }
+
+  /**
+   * @brief Deletes a node with the specified value from the binary search tree.
+   *
+   * This function deletes a node containing the value `x` from the binary
+   * search tree. It traverses the tree starting from the given root node and
+   * removes the node with the specified value if it exists.
+   *
+   * After the deletion, the function may adjust the tree structure to maintain
+   * its binary search tree properties.
+   *
+   * @param root A pointer to a pointer to the root node of the binary search
+   * tree.
+   * @param x The value to delete from the tree.
+   * @return A pointer to the updated root node of the tree after the deletion.
+   */
+  Node *_delete(Node **root, int x) {
+    if (!(*root)) {
+      return nullptr;
     }
-    postOrderTraversal(root->left);
-    postOrderTraversal(root->right);
-    std::cout << root->data << " ";
-}
-
-
 
-int main() {
-    Node* root = nullptr;
+    if (x < (*root)->data) {
+      (*root)->left = _delete(&((*root)->left), x);
+    } else if (x > (*root)->data) {
+      (*root)->right = _delete(&((*root)->right), x);
+    } else {
+      // Case 1: Leaf node
+      if (!((*root)->left) && !((*root)->right)) {
+        delete *root;
+        *root = nullptr;
+      }
+
+      // Case 2: Only one child
+      else if (!((*root)->left)) {
+        Node *tmp = *root;
+        *root = (*root)->right;
+        delete tmp;
+      } else if (!((*root)->right)) {
+        Node *tmp = *root;
+        *root = (*root)->left;
+        delete tmp;
+      }
+
+      // Case 3: Two children
+      else {
+        // Could've been <<< Node *tmp = _find_max((*root)->left); >>>
+        Node *tmp = _find_min((*root)->right);
+        (*root)->data = tmp->data;
+        (*root)->right = _delete(&((*root)->right), tmp->data);
+      }
+    }
+    return *root;
+  }
+
+  /**
+   * @brief Find the minimum node value in the binary search tree.
+   *
+   * This function searches the binary search tree starting from the given root
+   * node and returns a pointer to the node with the minimum value. The minimum
+   * value is found by recursively traversing the left child nodes until the
+   * smallest value is located.
+   *
+   * @param root A pointer to the root node of the binary search tree.
+   * @return A pointer to the node with the minimum value in the tree.
+   */
+  Node *_find_min(Node *root) const {
+    while (root && root->left) {
+      root = root->left;
+    }
+    return root;
+  }
+
+  /**
+   * @brief Find the maximum node value in the binary search tree.
+   *
+   * This function searches the binary search tree starting from the given root
+   * node and returns a pointer to the node with the maximum value. The maximum
+   * value is found by recursively traversing the right child nodes until the
+   * largest value is located.
+   *
+   * @param root A pointer to the root node of the binary search tree.
+   * @return A pointer to the node with the minimum value in the tree.
+   */
+  Node *_find_max(Node *root) const {
+    while (root && root->right) {
+      root = root->right;
+    }
+    return root;
+  }
+
+  /**
+   * @brief Prints the elements of the binary search tree in preorder traversal.
+   *
+   * The preorder traversal visits the current node first, followed by its left
+   * and right children - recursively.
+   *
+   * @param root A pointer to the root node of the binary search tree.
+   */
+  void _printPreorder(Node *root) const {
+    if (root) {
+      std::cout << root->data << '\n';
+      _printPreorder(root->left);
+      _printPreorder(root->right);
+    }
+  }
+
+  /**
+   * @brief Prints the elements of the binary search tree in inorder traversal.
+   *
+   * The inorder traversal visits the left child, followed by the current node,
+   * and then the right child recursively.
+   *
+   * @param root A pointer to the root node of the binary search tree.
+   */
+  void _printInorder(Node *root) const {
+    if (root) {
+      _printInorder(root->left);
+      std::cout << root->data << '\n';
+      _printInorder(root->right);
+    }
+  }
+
+  /**
+   * @brief Prints the elements of the binary search tree in postorder
+   * traversal.
+   *
+   * The postorder traversal visits the left and right children first, followed
+   * by the current node.
+   *
+   * @param root A pointer to the root node of the binary search tree.
+   */
+  void _printPostorder(Node *root) const {
+    if (root) {
+      _printPostorder(root->left);
+      _printPostorder(root->right);
+      std::cout << root->data << '\n';
+    }
+  }
+};
 
-    // insert elements into the binary tree
-    root = insert(root, 50);
-    root = insert(root, 30);
-    root = insert(root, 20);
-    root = insert(root, 40);
-    root = insert(root, 70);
-    root = insert(root, 60);
-    root = insert(root, 80);
+int main(int argc, char *argv[]) {
+  auto bst = BinarySearchTree();
 
-    // in-order traversal
-    std::cout << "In-order traversal: ";
-    inOrderTraversal(root);
-    std::cout << std::endl;
+  int arr[] = {30, 20, 10, 50, 40, 45, 80, 90};
+  for (const auto &e : arr) {
+    bst.insert(e);
+  }
 
-    // pre-order traversal
-    std::cout << "Pre-order traversal: ";
-    preOrderTraversal(root);
-    std::cout << std::endl;
+  std::cout << "inorder traversal:\n";
+  bst.inorderTraversal();
+  std::cout << "preorder traversal:\n";
+  bst.preorderTraversal();
+  std::cout << "postorder traversal:\n";
+  bst.postorderTraversal();
 
-    // post-order traversal
-    std::cout << "Post-order traversal: ";
-    postOrderTraversal(root);
-    std::cout << std::endl;
+  bst.deleteNode(50);
+  std::cout << "preorder traversal:\n";
+  bst.preorderTraversal();
 
-    return 0;
+  return 0;
 }