1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
|
#pragma once
#include <fstream>
#include <string>
#include "BinaryNode.h"
#include "LinkedQueue.h"
template <class T>
class MyBinarySearchTree
{
private:
BinaryNode<T>* _root;//A pointer to a BinaryNode<T> that is the root of our tree.
int _size;//Track of the size of our tree.
BinaryNode<T>* _insert(BinaryNode<T>* cur, T data);//Methord to add to tree.
void _preorder(std::string* ord, BinaryNode<T>* cur);//Pre order treversal methord.
void _inorder(std::string* ord, BinaryNode<T>* cur);//In order treversal methord.
void _postorder(std::string* ord, BinaryNode<T>* cur);//Post order treversal methord.
void _levelorder(std::string* ord, BinaryNode<T>* cur);//Level order treversal methord.
bool _binarySearch(BinaryNode<T>* cur, T data);//Search methord.
void _deleteTree(BinaryNode<T>* cur);//Delete methord that the deconstructor calls.
public:
MyBinarySearchTree();//Default Constructor
MyBinarySearchTree(std::string fName);//Constructor
MyBinarySearchTree(const MyBinarySearchTree<T>& obj);//Copy constructor
~MyBinarySearchTree();//Deconstructor
void insert(T data);//Adding helper methord.
std::string preorder();//Treversal helper methord.
std::string inorder();//Treversal helper methord.
std::string postorder();//Treversal helper methord.
std::string levelorder();//Treversal helper methord.
bool contains(T data);//Search helper methord.
int size();//Methord returning the size.
bool is_empty();//Methord to check if the tree is empty.
};
template <class T>
MyBinarySearchTree<T>::MyBinarySearchTree()//Default Constructor
{
_root=nullptr;//Because no nodes in the tree.
_size=0;//No nodes in the tree.
}
template <class T>
MyBinarySearchTree<T>::MyBinarySearchTree(std::string fName)//Constructor
{
std::ifstream nameFile;//Stream class to read from nameFile
nameFile.open(fName);//Open the file.
std::string peoplenames;//Defining string variable peoplenames.
while (getline(nameFile, peoplenames))//Read through the file.
{
insert(peoplenames);//Add peoplenames to the tree.
}
nameFile.close();//Close file.
}
template <class T>
MyBinarySearchTree<T>::MyBinarySearchTree(const MyBinarySearchTree<T>& obj)//Copy constructor
{
LinkedQueue<BinaryNode<T>*>* q = new LinkedQueue<BinaryNode<T>*>();//Creating a new linked queue holding pointers to nodes.
BinaryNode<T>* cn;//Node pointer variable.
MyBinarySearchTree<T>* cur=obj._root;//Copying the root node pointer to the tree pointer object cur.
q->enqueue(cur);//Enqueue the root.
while (!q->is_empty())//While the queue is not empty.
{
cn = q->dequeue();//Dequeue a node pointer object which cn points to now.
_insert(cn);//add the node pointer object to the tree.
if (cn->getLeft() != nullptr)
{
q->enqueue(cn->getLeft());//Enqueue the left child (if it exists).
}
if (cn->getRight() != nullptr)
{
q->enqueue(cn->getRight());//Enqueue the right child (if it exists).
}
}
delete q;//Delete the queue.
//Ripping off the idea used for a level order traversal, but instead of adding the contents to a string, just inserting the things into the tree.
}
template <class T>
MyBinarySearchTree<T>::~MyBinarySearchTree()//Deconstructor
{
_deleteTree(_root);//Calling the delete mothord.
}
template <class T>
void MyBinarySearchTree<T>::insert(T data)//Adding helper methord.
{
_root = _insert(_root, data);//calling the actual adding method with a node pointer variable and data transferred to the current method as parameters and setting it equal to the root.
_size++;//incresing the size of the tree.
}
template <class T>
BinaryNode<T>* MyBinarySearchTree<T>::_insert(BinaryNode<T>* cur, T data)//Methord to add to tree.
{
// Base case
if (cur == nullptr)// The pointer tranfered points to nothing.
{
return new BinaryNode<T>(data);//Create a new node with the data passed.
}
// Insert Left
if (data < cur->getData())//If the poiter's data is greater than the data passed.
{
cur->setLeft(_insert(cur->getLeft(), data));//Call the add methord again to create a node to the left of the current node holding the data tranfred.
}
// Insert Right
else
{
cur->setRight(_insert(cur->getRight(), data));//Call the add methord again to create a node to the right of the current node holding the data tranfred.
}
return cur;//Return root of the tree.
}
template <class T>
std::string MyBinarySearchTree<T>::preorder()//Treversal helper methord.
{
std::string order;//String variable
_preorder(&order,_root);//Call the actual treversal.
return order;//Returning string variable.
}
template <class T>
void MyBinarySearchTree<T>::_preorder(std::string* ord, BinaryNode<T>* cur)
{
if (cur != nullptr)//If the tree is not empty
{
*ord = *ord + cur->getData() + ", ";//Visit the root node of the tree (print?).
_preorder(ord,cur->getLeft());//Do a preorder traversal on the left subtree
_preorder(ord,cur->getRight());//Do a preorder traversal on the right subtree
}
}
template <class T>
std::string MyBinarySearchTree<T>::inorder()//Treversal helper methord.
{
std::string order;//String variable
_inorder(&order, _root);//Call the actual treversal.
return order;//Returning string variable.
}
template <class T>
void MyBinarySearchTree<T>::_inorder(std::string* ord, BinaryNode<T>* cur)
{
if (cur != nullptr)//If the tree is not empty
{
_inorder(ord, cur->getLeft());//Do a inorder traverrsal on the left subtree
*ord = *ord + cur->getData() + ", ";//Visit the root node of the tree (print?)
_inorder(ord, cur->getRight());//Do a inordr traverrsal on the right subtree
}
}
template <class T>
std::string MyBinarySearchTree<T>::postorder()//Treversal helper methord.
{
std::string order;//String variable
_postorder(&order, _root);//Call the actual treversal.
return order;//Returning string variable.
}
template<class T>
void MyBinarySearchTree<T>::_postorder(std::string* ord, BinaryNode<T>* cur)
{
if (cur != nullptr)//If the tree is not empty
{
_postorder(ord, cur->getLeft());//Do a postorder traverrsal on the left subtree
_postorder(ord, cur->getRight());// Do a inordr traverrsal on the right subtree
*ord = *ord + cur->getData() + ", ";//Visit the root node of the tree (print?)
}
}
template <class T>
std::string MyBinarySearchTree<T>::levelorder()//Treversal helper methord.
{
std::string order;//String variable
_levelorder(&order, _root);//Call the actual treversal.
return order;//Returning string variable.
}
template <class T>
void MyBinarySearchTree<T>::_levelorder(std::string* ord, BinaryNode<T>* cur)
{
LinkedQueue<BinaryNode<T>*>* q = new LinkedQueue<BinaryNode<T>*>();//Creating a new linked queue holding pointers to nodes.
BinaryNode<T>* cn;//Node pointer variable.
q->enqueue(cur);//Enqueue the cur node pointer passed.
while (!q->is_empty())//While the queue is not empty.
{
cn = q->dequeue();//Dequeue a node pointer object which cn points to now.
*ord = *ord + cn->getData() + ", ";//Adding the contents to a string.
if (cn->getLeft() != nullptr)
{
q->enqueue(cn->getLeft());//Enqueue the left child (if it exists).
}
if (cn->getRight() != nullptr)
{
q->enqueue(cn->getRight());//Enqueue the right child (if it exists).
}
}
delete q;//Delete the queue.
}
template <class T>
bool MyBinarySearchTree<T>::contains(T data)//Search helper methord.
{
return _binarySearch(_root, data);//Return the status of the search.
}
template <class T>
bool MyBinarySearchTree<T>::_binarySearch(BinaryNode<T>* cur, T data)
{
if (cur == nullptr)//If the passes node pointer points to nothing
{
return false;//Return not found.
}
if (data == cur->getData())//If the passes node pointer points to the data passes
{
return true;//Return found.
}
if (data < cur->getData())//If the data passes is less than the node pointer's data
{
return _binarySearch(cur->getLeft(), data);//Do a binary search on the left.
}
else
{
return _binarySearch(cur->getRight(), data);//Do a binary search on the right.
}
}
|