//========================makeEmptyHelper============================= // Deletes the nodes in the given tree recursively. // // Preconditions: root is not NULL. // // Postconditions: The tree is empty. //==================================================================== void BSTree::makeEmptyHelper (Node *&root) const { if (root != NULL) { makeEmptyHelper (root->left); makeEmptyHelper (root->right); delete root->item; delete root; root->item = NULL; } root = NULL; }
void BinTree::makeEmptyHelper( Node* currentNode ) { // check that their is something in the data location to delete if ( currentNode->left != NULL ) { makeEmptyHelper( currentNode->left ); } if ( currentNode->right != NULL ) { makeEmptyHelper( currentNode->right ); } delete currentNode->data; delete currentNode; }
//------------------------------------------------------------------------------ // makeEmptyHelper // helper to makeEmpty function void BSTree::makeEmptyHelper(Node* target) { if(target == NULL) { return; } makeEmptyHelper(target->left); makeEmptyHelper(target->right); delete target->data; target->data = NULL; target->left = NULL; target->right = NULL; delete target; target = NULL; }
//---------------------------------------------------------------------------- // makeEmptyHelper // This is a helper function that deletes nodes and data. void BinTree::makeEmptyHelper(Node*& head){ if(head != NULL){ // going through the tree makeEmptyHelper(head->left); makeEmptyHelper(head->right); // deleting the stuff delete head->data; head->data = NULL; delete head; head = NULL; } }
void BinTree::makeEmpty(){ // only delete the tree if it isn't already empty if ( !isEmpty() ) { makeEmptyHelper( root ); // start deleting from the root, recursively } root = NULL; }
//////////////////////////////////////////////////////////////////////////////////////////////////// // Assignment Operator: assigns a tree (via CopyTree). // Pre Conditions: Trees are properly initialized // Post Conditions: copies the source tree into its own tree if they are not the same //////////////////////////////////////////////////////////////////////////////////////////////////// BinTree& BinTree::operator=(const BinTree &source) { if (&source != this) { makeEmptyHelper(this->root); CopyTree(this->root, source.root); } return *this; }
//////////////////////////////////////////////////////////////////////////////////////////////////// // makeEmptyhelper: Helper function to make the tree empty recursively // Pre Conditions: Tree is properly initialized // Post Conditions: tree is made empty //////////////////////////////////////////////////////////////////////////////////////////////////// void BinTree::makeEmptyHelper(Node* ¤t) { if (current == NULL) { return; } if (current->left != NULL || current->right != NULL) { makeEmptyHelper(current->left); makeEmptyHelper(current->right); current->left = NULL; current->right = NULL; } if (current->left == NULL && current->right == NULL) { delete current; return; } }
//------------------------------------------------------------------------------ // makeEmpty // deallocates all memory from the tree void BSTree::makeEmpty() { makeEmptyHelper(root); }
//////////////////////////////////////////////////////////////////////////////////////////////////// // makeEmpty: Function to make tree empty // Pre Conditions: Tree is properly initialized // Post Conditions: Tree is empty and root is set to NULL //////////////////////////////////////////////////////////////////////////////////////////////////// void BinTree::makeEmpty() { makeEmptyHelper(root); root = NULL; }