#include "Tree.h" Root = nullptr;

Transcription

1 #include "Tree.h" Tree::Tree() ******* //Output marker 1 ******* cout << "Birth certifiacte of a Tree object" << endl; ******* Root = nullptr; Tree :: ~Tree() ******* //Output marker 2 ******* cout << "Death certifiacte of a Tree object" << endl; ******* DeleteCompleteTree(Root); //The only difference from Display is // the call to DisplayTreeX in the code void Tree::DisplayX() cout << endl << "Contents in the tree:" << endl; DisplayTreeX(Root); cout << endl; //The only difference from DisplayTree is // the order of displaying the contents void Tree::DisplayTreeX(TreeNode * SubtreeRoot) if (SubtreeRoot!= nullptr) DisplayTreeX(SubtreeRoot->Left); DisplayTreeX(SubtreeRoot->Right); cout << SubtreeRoot->Value << endl; //The only difference from Insert is // the call to InsertTreeX in the code void Tree::InsertX(int Val)

2 InsertTreeX(Root, Val); //The only difference from InsertTree is // the type of the parameter SubtreeRoot void Tree::InsertTreeX(TreeNode * SubtreeRoot, int Val) SubtreeRoot = new TreeNode; SubtreeRoot->Left = nullptr; SubtreeRoot->Right = nullptr; SubtreeRoot->Value = Val; // handle the duplicate if (Val == SubtreeRoot->Value) //search to the Left if (Val < SubtreeRoot->Value) InsertTreeX(SubtreeRoot->Left, Val); //search to the Right InsertTreeX(SubtreeRoot->Right, Val); //The only difference from Insert is // the call to InsertTreeX in the code int Tree::Fun1() return Fun1_Of_Tree(Root); //The only difference from InsertTree is // the type of the parameter SubtreeRoot int Tree::Fun1_Of_Tree(TreeNode * SubtreeRoot) return 0; int result; result = 1 return result; + Fun1_Of_Tree(SubtreeRoot->Left) + Fun1_Of_Tree(SubtreeRoot->Right); //Hint: Compare it with Search

3 TreeNode * Tree::GetPointer(int Val) return GetPointerTree(Root, Val); //Hint: Compare it with SearchTree TreeNode * Tree::GetPointerTree(TreeNode * SubtreeRoot, int Val) return nullptr; if (SubtreeRoot->Value == Val) return SubtreeRoot; if (Val < SubtreeRoot->Value) return GetPointerTree(SubtreeRoot->Left, Val); return GetPointerTree(SubtreeRoot->Right, Val); //Hint: Compare it with GetPredecessor int Tree::GetX(int Val) TreeNode * SubtreeRoot; SubtreeRoot = GetPointer(Val); return -1; TreeNode * temp = SubtreeRoot; while (temp->right!= nullptr) temp = temp->right; int data = temp->value; return data; ******** // The following is the same as the original code ******** void Tree :: Clear() DeleteCompleteTree(Root); Root = nullptr; void Tree :: Insert(int Val)

4 InsertTree(Root, Val); void Tree :: InsertTree(TreeNode * & SubtreeRoot, int Val) if (SubtreeRoot==nullptr) SubtreeRoot= new TreeNode; SubtreeRoot->Left=nullptr; SubtreeRoot->Right=nullptr; SubtreeRoot->Value = Val; // handle duplicate if (Val == SubtreeRoot->Value) //search Left if (Val < SubtreeRoot->Value) InsertTree(SubtreeRoot->Left, Val); //search Right InsertTree(SubtreeRoot->Right,Val); void Tree::Display() cout << endl << "Contents in the tree:" << endl; DisplayTree(Root); cout << endl; void Tree :: DisplayTree(TreeNode * SubtreeRoot) if (SubtreeRoot!= nullptr) DisplayTree(SubtreeRoot->Left); cout<<subtreeroot->value << endl; DisplayTree(SubtreeRoot->Right); void Tree::Write(ostream & output) WriteTree(output, Root); cout << endl; void Tree :: WriteTree(ostream & output, TreeNode * SubtreeRoot) if (SubtreeRoot!= nullptr) WriteTree(output, SubtreeRoot->Left); output << SubtreeRoot->Value << endl;

5 WriteTree(output, SubtreeRoot->Right); bool Tree:: Search(int Val) return SearchTree(Root, Val); bool Tree:: SearchTree(TreeNode * SubtreeRoot, int Val) return false; if (SubtreeRoot->Value == Val) return true; if (Val < SubtreeRoot->Value) return SearchTree(SubtreeRoot->Left, Val); return SearchTree(SubtreeRoot->Right, Val); void Tree :: DeleteCompleteTree(TreeNode * SubtreeRoot) if (SubtreeRoot!= nullptr) DeleteCompleteTree(SubtreeRoot->Left); DeleteCompleteTree(SubtreeRoot->Right); delete SubtreeRoot; ************* // The following are three global functions as additional Code // used to support the deletion of a node from a tree // Not in the book **** bool Tree::GetPredecessor(TreeNode * SubtreeRoot, int& data) // Find the predecessor of the root node in SubtreeRoot. // If there is one, return true and store the predecessor data in data //Otherwise, return false. if (SubtreeRoot == nullptr (SubtreeRoot->Left) == nullptr) return false; TreeNode * temp = SubtreeRoot->Left; while (temp->right!= nullptr) temp = temp->right; data = temp->value; return true;

6 void Tree::DeleteItem(TreeNode *& SubtreeRoot, int item) // Deletes item from tree. // Post: item is not in tree rooted at SubtreeRoot. if (item < SubtreeRoot->Value) DeleteItem(SubtreeRoot->Left, item); if (item > SubtreeRoot->Value) DeleteItem(SubtreeRoot->Right, item); DeleteNode(SubtreeRoot); // Look in Left subtree. // Look in Right subtree. // Node found; call DeleteNode. void Tree::DeleteNode(TreeNode *& SubtreeRoot) // Deletes the node pointed to by SubtreeRoot. //cout << "To delete " << tree->value << endl; if (SubtreeRoot->Left!= nullptr && SubtreeRoot->Right!= nullptr) int data; GetPredecessor(SubtreeRoot, data); SubtreeRoot->Value = data; DeleteItem(SubtreeRoot->Left, data); TreeNode * tempptr; tempptr = SubtreeRoot; // Delete predecessor node. if (SubtreeRoot->Left == nullptr) SubtreeRoot = SubtreeRoot->Right; if (SubtreeRoot->Right == nullptr) SubtreeRoot = SubtreeRoot->Left; delete tempptr; ****************** // The following is an additional member function of the Tree class. // It directly or indirectly uses the three functions above to // delete an item from the tree. // Not in the book **** void Tree::Delete(int item) // Calls recursive function Delete to delete item from tree. DeleteItem(Root, item);

7 //Clear and empty the current tree. //Read int values from the istream object "input", which may represent a file or just cin //and then store them into the Tree "atree". // istream & operator>> (istream & input, Tree & atree) int n; if (&input == &cin) n = -1; while (n < 0) cout << "How many elements to add into the linked list?"; cin >> n; atree.clear(); cout << endl << "Enter them one by one" << endl; for (int i=0; i<n; i++) int temp; cout << "[" << i << "]:"; cin >> temp; atree.insert(temp); // (&input!= &cin) input >> n; if (n >= 0) atree.clear(); return input; for (int i=0; i<n; i++) int temp; input >> temp; atree.insert(temp); return input; //Writing out the integer values currently stored in the Tree "atree" //into the ostream object "output", which may represent a file or just cout. ostream & operator<< (ostream & output, Tree & atree)

8 if (&output == &cout) atree.display(); //(output!= cout) atree.write(output); return output;