the pointer range [first, last) into the tree

Transcription

1 1 #ifndef BINARY_SEARCH_TREE_CLASS 2 #define BINARY_SEARCH_TREE_CLASS 3 4 #ifndef NULL 5 #include <cstddef> 6 #endif // NULL 7 8 #include <iomanip> // for setw() 9 #include <strstream> // for format conversion 10 #include <string> // node data formatted as a string 11 #include <queue> 12 #include <utility> // pair class #include "d_except.h" // exception classes using namespace std; // declares a binary search tree node object 19 template <typename T> 20 class stnode { 21 public: 22 // stnode is used to implement the binary search tree class 23 // making the data public simplifies building the class functions T nodevalue; // node data 26 stnode<t> *left, *right, *parent; // child pointers and pointer to the node s parent // constructor 29 stnode (const T& item, stnode<t> *lptr = NULL, stnode<t> *rptr = NULL, stnode<t> *pptr = NULL): nodevalue(item), left(lptr), right(rptr), parent(pptr) {} 30 }; template <typename T> 33 class stree { 34 public: // include the iterator nested classes 37 #include "d_stiter.h" stree(); // constructor. initialize root to NULL and size to 0 40 stree(t *first, T *last); // constructor. insert the elements from the pointer range [first, last) into the tree 41 stree(const stree<t>& tree); // copy constructor 42 ~stree(); // destructor 1

2 43 stree<t>& operator= (const stree<t>& rhs); // assignment operator iterator find(const T& item); // search for item. if found, return an iterator pointing at it in the tree; otherwise, return end() 46 const_iterator find(const T& item) const; // constant version int empty() const; // indicate whether the tree is empty 49 int size() const; // return the number of data items in the tree pair<iterator, bool> insert(const T& item); 52 // if item is not in the tree, insert it and return a pair whose iterator component points at item and whose bool component is true. if item is in the tree, return a pair whose iterator component points at the existing item and whose bool component is false 53 // Postcondition: the tree size increases by 1 if item is not in the tree void erase(iterator pos); 56 // erase the item pointed to by pos. Preconditions: the tree is not empty and pos points to an item in the tree. if the tree is empty, the function throws the underflowerror exception. if the iterator is invalid, the function throws the referenceerror exception. Postcondition: the tree size decreases by iterator begin(); // return an iterator pointing to the first item inorder 59 iterator end(); // return an iterator pointing just past the end of the tree data private: 62 stnode<t> *root; // pointer to tree root 63 int treesize; // number of elements in the tree stnode<t> *getstnode(const T& item, stnode<t> *lptr,stnode<t> *rptr, stnode<t> *pptr); 66 // allocate a new tree node and return a pointer to it. if memory allocation fails, the function throws the memoryallocationerror exception stnode<t> *copytree(stnode<t> *t); 69 // recursive function used by copy constructor and assignment operator to assign the current tree as a copy of another tree void deletetree(stnode<t> *t); 72 // recursive function used by destructor and assignment operator 2

3 73 to delete all the nodes in the tree 74 stnode<t> *findnode(const T& item) const; 75 // search for item in the tree. if it is in the tree, return a pointer to its node; otherwise, return NULL. used by find() and erase() }; template <typename T> 80 stnode<t> *stree<t>::getstnode(const T& item, 81 stnode<t> *lptr,stnode<t> *rptr, stnode<t> *pptr) { 82 stnode<t> *newnode; // initialize the data and all pointers 85 newnode = new stnode<t> (item, lptr, rptr, pptr); 86 if (newnode == NULL) throw memoryallocationerror("stree: memory allocation failure"); return newnode; 89 } template <typename T> 92 stnode<t> *stree<t>::copytree(stnode<t> *t) { 93 stnode<t> *newlptr, *newrptr, *newnode; // if tree branch NULL, return NULL 96 if (t == NULL) return NULL; // copy the left branch of root t and assign its root to newlptr 99 newlptr = copytree(t->left); // copy the right branch of tree t and assign its root to newrptr 102 newrptr = copytree(t->right); // allocate storage for the current root node, assign its value and pointers to its left and right subtrees. the parent pointer of newnode is assigned when newnode s parent is created. if newnode is root, NULL is the correct value for its parent pointer 105 newnode = getstnode(t->nodevalue, newlptr, newrptr, NULL); // the current node is the parent of any subtree that is not empty 108 if (newlptr!= NULL) newlptr->parent = newnode; 109 if (newrptr!= NULL) newrptr->parent = newnode; return newnode; 3

4 112 } // delete the tree stored by the current object 115 template <typename T> 116 void stree<t>::deletetree(stnode<t> *t) { 117 // if current root node is not NULL, delete its left subtree, its right subtree and then the node itself 118 if (t!= NULL) { 119 deletetree(t->left); 120 deletetree(t->right); 121 delete t; 122 } 123 } // search for data item in the tree. if found, return its node address; otherwise, return NULL 126 template <typename T> 127 stnode<t> *stree<t>::findnode(const T& item) const { 128 // cycle t through the tree starting with root 129 stnode<t> *t = root; // terminate on on empty subtree 132 while(t!= NULL &&!(item == t->nodevalue)) 133 if (item < t->nodevalue) t = t->left; 134 else t = t->right; // return pointer to node; NULL if not found 137 return t; 138 } template <typename T> 141 stree<t>::stree(): root(null),treesize(0) {} template <typename T> 144 stree<t>::stree(t *first, T *last): root(null),treesize(0) { 145 T *p = first; // insert each item in [first, last) into the tree 148 while (p!= last) { 149 insert(*p); 150 p++; 151 } 152 } template <typename T> 155 stree<t>::stree(const stree<t>& tree): treesize(tree.treesize) { 4

5 156 root = copytree(tree.root); // copy tree to the current object 157 } template <typename T> 160 stree<t>::~stree() { 161 // erase the tree nodes from memory 162 deletetree(root); 163 } template <typename T> 166 stree<t>& stree<t>::operator= (const stree<t>& rhs) { 167 if (this == &rhs) // can t copy a tree to itself 168 return *this; deletetree(root); // erase the existing tree nodes from memory 171 root = copytree(rhs.root); // copy tree rhs into current object 172 treesize = rhs.treesize; // set the tree size return *this; // return reference to current object 175 } template <typename T> 178 stree<t>::iterator stree<t>::find(const T& item) { 179 stnode<t> *curr = findnode (item); // search tree for item // if item found, return iterator with value current; otherwise, return end() 182 if (curr!= NULL) return iterator(curr, this); 183 else return end(); 184 } template <typename T> 187 int stree<t>::empty() const { return root == NULL; } template <typename T> 190 int stree<t>::size() const { return treesize; } template <typename T> 193 pair<stree<t>::iterator, bool> stree<t>::insert(const T& item) { 194 // t is current node in traversal, parent the previous node 195 stnode<t> *t = root, *parent = NULL, *newnode; // terminate on on empty subtree 198 while(t!= NULL) { 199 // update the parent pointer. then go left or right 200 parent = t; 5

6 201 // if a match occurs, return a pair whose iterator component points at item in the tree and whose bool component is false 202 if (item == t->nodevalue) 203 return pair<iterator, bool> (iterator(t, this), false); 204 else if (item < t->nodevalue) 205 t = t->left; 206 else 207 t = t->right; 208 } // create the new leaf node 211 newnode = getstnode(item,null,null,parent); // if parent is NULL, insert as root node 214 if (parent == NULL) 215 root = newnode; 216 else if (item < parent->nodevalue) 217 // insert as left child 218 parent->left = newnode; 219 else 220 // insert as right child 221 parent->right = newnode; // increment size 224 treesize++; // return a pair whose iterator component points at the new node and whose bool component is true 227 return pair<iterator, bool> (iterator(newnode, this), true); 228 } template <typename T> 231 void stree<t>::erase(iterator pos) { 232 // dnodeptr = pointer to node D that is deleted 233 // pnodeptr = pointer to parent P of node D 234 // rnodeptr = pointer to node R that replaces D 235 stnode<t> *dnodeptr = pos.nodeptr, *pnodeptr, *rnodeptr; if (treesize == 0) throw underflowerror("stree erase(): tree is empty"); 238 if (dnodeptr == NULL) throw referenceerror("stree erase(): invalid iterator"); // assign pnodeptr the address of P 241 pnodeptr = dnodeptr->parent; // If D has a NULL pointer, the replacement node is the other child 6

7 244 if (dnodeptr->left == NULL dnodeptr->right == NULL) { 245 if (dnodeptr->right == NULL) rnodeptr = dnodeptr->left; 246 else rnodeptr = dnodeptr->right; if (rnodeptr!= NULL) // the parent of R is now the parent of D 249 rnodeptr->parent = pnodeptr; 250 } 251 else { // both pointers of dnodeptr are non-null 252 // find and unlink replacement node for D. starting at the right child of node D, find the node whose value is the smallest of all nodes whose values are greater than the value in D. unlink the node from the tree. 253 stnode<t> *pofrnodeptr = dnodeptr; // pofrnodeptr = pointer to parent of replacement node 254 rnodeptr = dnodeptr->right; // first possible replacement is right child of D // descend down left subtree of the right child of D, keeping a record of current node and its parent. when we stop, we have found the replacement 257 while(rnodeptr->left!= NULL) { 258 pofrnodeptr = rnodeptr; 259 rnodeptr = rnodeptr->left; 260 } if (pofrnodeptr == dnodeptr) { 263 // right child of deleted node is the replacement. 264 // assign left subtree of D to left subtree of R 265 rnodeptr->left = dnodeptr->left; 266 // assign the parent of D as the parent of R 267 rnodeptr->parent = pnodeptr; 268 // assign the left child of D to have parent R 269 dnodeptr->left->parent = rnodeptr; 270 } 271 else { 272 // we moved at least one node down a left branch of the right child of D. unlink R from tree by assigning its right subtree as the left child of the parent of R 273 pofrnodeptr->left = rnodeptr->right; // the parent of the right child of R is the parent of R 276 if (rnodeptr->right!= NULL) 277 rnodeptr->right->parent = pofrnodeptr; // put replacement node in place of dnodeptr. assign children of R to be those of D 7

8 280 rnodeptr->left = dnodeptr->left; 281 rnodeptr->right = dnodeptr->right; 282 // assign the parent of R to be the parent of D 283 rnodeptr->parent = pnodeptr; 284 // assign the parent pointer in the children of R to point at R 285 rnodeptr->left->parent = rnodeptr; 286 rnodeptr->right->parent = rnodeptr; 287 } 288 } // complete the link to the parent node. 291 // deleting the root node. assign new root 292 if (pnodeptr == NULL) 293 root = rnodeptr; 294 // attach R to the correct branch of P 295 else if (dnodeptr->nodevalue < pnodeptr->nodevalue) 296 pnodeptr->left = rnodeptr; 297 else 298 pnodeptr->right = rnodeptr; // delete the node from memory and decrement tree size 301 delete dnodeptr; 302 treesize--; 303 } template <typename T> 306 stree<t>::iterator stree<t>::begin() { 307 stnode<t> *curr = root; // if the tree is not empty, the first node inorder is the farthest node left from root 310 if (curr!= NULL) 311 while (curr->left!= NULL) 312 curr = curr->left; // build return value using private constructor 315 return iterator(curr, this); 316 } template <typename T> 319 stree<t>::iterator stree<t>::end() { 320 // end indicated by an iterator with NULL stnode pointer 321 return iterator(null, this); 322 } #endif // BINARY_SEARCH_TREE_CLASS 8