/*############################################################################# ## Author: Shaun Reed ## ## Legal: All Content (c) 2021 Shaun Reed, all rights reserved ## ## About: An example of a red-black tree implementation ## ## The algorithms in this example are seen in MIT Intro to Algorithms ## ## ## ## Contact: shaunrd0@gmail.com | URL: www.shaunreed.com | GitHub: shaunrd0 ## ############################################################################## */ #include "redblack.h" /******************************************************************************* * Constructors, Destructors, Operators *******************************************************************************/ /** BinarySearchTree Copy Assignment Operator * @brief Empty the calling object's root BinaryNode, and copy the rhs data * * Runs in O( n ) time, since we visit each node in the BST once * + Where n is the total number of nodes within the BST * * makeEmpty() and clone() are both O( n ), and we call each sequentially * + This would appear to be O( 2n ), but we drop the constant of 2 * * @param rhs The BST to copy, beginning from its root BinaryNode * @return BinarySearchTree The copied BinarySearchTree object */ BinarySearchTree& BinarySearchTree::operator=(const BinarySearchTree &rhs) { // If the objects are already equal, do nothing if (this == &rhs) return *this; // Empty this->root makeEmpty(root); // Copy rhs to this->root root = clone(rhs.root); return *this; } /* BinaryNode Copy Constructor * * Runs in O( n ) time, since we visit each node in the BST once * + Where n is the total number of nodes within the BST * * @param rhs An existing BST to initialize this node (and children) with */ BinarySearchTree::BinaryNode::BinaryNode(BinaryNode * toCopy) { // Base case, breaks recursion when we hit a null node // + Returns to the previous call in the stack if (toCopy == nullptr) return; // Set the element of this BinaryNode to the value in toCopy->element element = toCopy->element; // If there is a left / right node, copy it using recursion // + If there is no left / right node, set them to nullptr if (toCopy->left != nullptr) { left = new BinaryNode(toCopy->left); left->parent = this; } if (toCopy->right != nullptr) { right = new BinaryNode(toCopy->right); right->parent = this; } } /******************************************************************************* * Public Member Functions *******************************************************************************/ /** contains * @brief Determines if value exists within a BinaryNode and its children * * Runs in O( height ) time, given the height of the current BST * + In the worst case, we search for a node at the bottom of the BST * * @param value The value to search for within the BST * @param start The root BinaryNode to begin the search * @return true If the value is found within the root node or its children * @return false If the value is not found within the root node or its children */ bool BinarySearchTree::contains(const int &value, BinaryNode *start) const { // If tree is empty if (start == nullptr) return false; // If x is smaller than our current value else if (value < start->element) return contains(value, start->left); // If x is larger than our current value, check the right node else if (value > start->element) return contains(value, start->right); else return true; } /** makeEmpty * @brief Recursively delete the given root BinaryNode and all of its children * * Runs in O( n ) time, since we need to visit each node in the tree once * + Where n is the total number of nodes in the tree * * @param tree The root BinaryNode to delete, along with all child nodes */ void BinarySearchTree::makeEmpty(BinarySearchTree::BinaryNode * & tree) { // Base case: When all nodes have been deleted, tree is a nullptr // + Breaks from recursion if (tree != nullptr) { makeEmpty(tree->left); makeEmpty(tree->right); delete tree; tree = nullptr; } } /** isEmpty * @brief Determine whether or not the calling BST object is empty * * Runs in constant time, O( 1 ) * * @return true If this->root node points to an empty tree (nullptr) * @return false If this->root node points to a constructed BinaryNode */ bool BinarySearchTree::isEmpty() const { return root == nullptr; } /** insert * @brief Insert a value into the tree starting at a given BinaryNode * + Uses recursion * * Runs in O( height ) time, since in the worst case we insert the node at the * + bottom of the BST. * * @param newValue The value to be inserted * @param start The BinaryNode to begin insertion * @param prevNode The last checked BinaryNode * + prevNode is used to initialize new node's parent */ void BinarySearchTree::insert(const int &newValue, BinaryNode *&start, BinaryNode *prevNode) { // Base case: We found a valid position which is empty for the newValue if (start == nullptr) { // Build a new node, place it at the current position // + Breaks out of recursion start = new BinaryNode(newValue, nullptr, nullptr, prevNode); } else if (newValue < start->element) insert(newValue, start->left, start); else if (newValue > start->element) insert(newValue, start->right, start); else return; } /** remove * @brief Removes a value from the BST of the given BinaryNode * * Runs in O( height ) time, where findMin() is the limiting function * + remove() and transplant() otherwise run in constant time, without findMin() * * @param removeNode The BinaryNode to remove from the BST */ void BinarySearchTree::remove(BinaryNode *removeNode) { if (removeNode->left == nullptr) { // removeNode has no left node; Replace removeNode with removeNode->right // + It doesn't matter if removeNode->right is nullptr or a valid node // + Since there is no left node, this is the only possible valid transplant // Transplant the right node and its subtree over this node transplant(removeNode, removeNode->right); } else if (removeNode->right == nullptr) { // removeNode has no right node; Replace removeNode with removeNode->right // + removeNode->left exists, in this case transplant(removeNode, removeNode->left); } else { // removeNode has a right and left node, find the next value in-order // + findMin(removeNode->right) returns the next largest value in the BST BinaryNode *minNode = findMin(removeNode->right); // If the next value in-order is not removeNode->right if (minNode->parent != removeNode) { // replace minNode with the next largest attached value, minNode->right transplant(minNode, minNode->right); // Set minNode->right to the node at removeNode->right // + Update the parent of removeNode->right accordingly in the next line minNode->right = removeNode->right; minNode->right->parent = minNode; } // Replace removeNode with the next node in-order // + Update the minNode's left and parent nodes in the following lines transplant(removeNode, minNode); minNode->left = removeNode->left; minNode->left->parent = minNode; } } /** printInOrder * @brief Uses recursion to output left subtree, root node, then right subtrees * * Runs in O( n ) time, since we need to visit each node in the tree once * + Where n is the total number of nodes within the BST * * @param start The root BinaryNode to begin the 'In Order' output */ void BinarySearchTree::printInOrder(BinaryNode *start) const { if(start != nullptr) { printInOrder(start->left); std::cout << start->element << " "; printInOrder(start->right); } } /** printPostOrder * @brief Uses recursion to output left subtree, right subtree, then the root * * Runs in O( n ) time, since we need to visit each node in the tree once * + Where n is the total number of nodes within the BST * * @param start The root BinaryNode to begin the 'Post Order' output */ void BinarySearchTree::printPostOrder(BinaryNode *start) const { if (start != nullptr) { printPostOrder(start->left); printPostOrder(start->right); std::cout << start->element << " "; } } /** printPreOrder * @brief Uses recursion to output the root, then left subtree, right subtrees * * Runs in O( n ) time, since we need to visit each node in the tree once * + Where n is the total number of nodes within the BST * * @param start The root BinaryNode to begin the 'Pre Order' output */ void BinarySearchTree::printPreOrder(BinaryNode *start) const { if (start != nullptr) { std::cout << start->element << " "; printPreOrder(start->left); printPreOrder(start->right); } } /** search * @brief Search for a given value within a tree or subtree using recursion * * Runs in O( height ) time * + In the worst case, we are searching for a node at the bottom of the BST * * @param value The value to search for * @param start The node to start the search from; Can be a subtree * @return A pointer to the BinaryNode containing the value within the BST * + Returns nullptr if the node was not found */ BinarySearchTree::BinaryNode *BinarySearchTree::search( const int &value, BinaryNode *start) const { // Base case: If BST is empty, or holds the value we are searching for // + Breaks out of recursion if (start == nullptr || start->element == value) return start; else if (start->element < value) return search(value, start->right); else if (start->element > value) return search(value, start->left); } /** findMin * @brief Find the minimum value within the BST of the given BinaryNode * + This example uses a while loop; findMax uses recursion * * Runs in O( height ) time * + In the worst case, we traverse to to the left-most bottom of the BST * * @param start The root BinaryNode to begin checking values * @return A pointer to the BinaryNode which contains the smallest value * + Returns nullptr if BST is empty */ BinarySearchTree::BinaryNode * BinarySearchTree::findMin(BinaryNode *start) const { // If our tree is empty if (start == nullptr) return nullptr; while (start->left != nullptr) start = start->left; // If current node has no smaller children, it is min return start; } /** findMax * @brief Find the maximum value within the BST of the given BinaryNode * + This example uses recursion; findMin uses a while loop * ++ Both functions can be implemented using a loop or recursion * * Runs in O( height ) time * + In the worst case, we traverse to to the right-most bottom of the BST * * @param start The root BinaryNode to begin checking values * @return A pointer to the BinaryNode which contains the largest value * + returns nullptr if BST is empty */ BinarySearchTree::BinaryNode * BinarySearchTree::findMax(BinaryNode *start) const { // If our tree is empty if (start == nullptr) return nullptr; // Base case: If current node has no larger children, it is max; Break recursion if (start->right == nullptr) return start; // Move down the right side of our tree and check again return findMax(start->right); } /** predecessor * @brief Finds the previous value in-order from the value at a given startNode * * Runs in O( height ) time * + In the worst case we traverse to the bottom of the BST * * @param startNode The node containing the value to find predecessor of * @return The node which is the predecessor of startNode */ BinarySearchTree::BinaryNode * BinarySearchTree::predecessor(BinaryNode *startNode) const { if (startNode->left != nullptr) return findMax(startNode->left); // If startNode has a parent, walk up the tree until we reach the top // + If startNode has no parent, we set it to nullptr and return BinaryNode *temp = startNode->parent; while (temp != nullptr && temp->left == startNode) { startNode = temp; temp = temp->parent; } return temp; } /** successor * @brief Finds the next value in-order from the value at a given startNode * * Runs in O( height ) time * + In the worst case we traverse to the bottom of the BST * * @param startNode The node containing the value to find successor of * @return The node which is the successor of startNode */ BinarySearchTree::BinaryNode * BinarySearchTree::successor(BinaryNode *startNode) const { // If there is a right subtree, next value in-order is findMin(rightSubtree) if (startNode->right != nullptr) return findMin(startNode->right); // If startNode has a parent, walk up the tree until we reach the top // + If startNode has no parent, we set it to nullptr and return BinaryNode *temp = startNode->parent; while (temp != nullptr && temp->right == startNode) { startNode = temp; temp = temp->parent; } return temp; } /******************************************************************************* * Private Member Functions *******************************************************************************/ /** clone * @brief Clone a BST node and all its children using recursion * * Runs in O( n ) time, since each node must be copied individually * * @param start The node to begin cloning from * @return A pointer to the BinaryNode which is root node of the copied tree */ BinarySearchTree::BinaryNode * BinarySearchTree::clone(BinaryNode *start) { // Base case: There is nothing to copy, break from recursion if (start == nullptr) return nullptr; // Construct all child nodes through recursion, return root node return new BinaryNode(start); } /** transplant * @brief Replaces, or overwrites, a node and with a new node * + The subtree attaches to oldNode is replace with that of newNode * * Runs in constant O( 1 ) time * + We only need to check and update values immediately available * * @param oldNode The node to overwrite with newNode * @param newNode The new node to take the place of oldNode */ void BinarySearchTree::transplant(BinaryNode *oldNode, BinaryNode *newNode) { // case 1: If oldNode is the root node at this->root // + 2: if the oldNode is the left child of it's parent // + 3: case if the oldNode is the right child of it's parent if (oldNode->parent == nullptr) root = newNode; else if (oldNode == oldNode->parent->left) { // Update the parent of oldNode to reflect the transplant oldNode->parent->left = newNode; } else if (oldNode == oldNode->parent->right) { // Update the parent of oldNode to reflect the transplant oldNode->parent->right = newNode; } // If we did not replace oldNode with a nullptr, update newNode's parent if (newNode != nullptr) newNode->parent = oldNode->parent; }