Added BST implementation

BinarySearchTree.cpp

@@ -1 +1,63 @@
 #include "BinarySearchTree.h"
+
+template<typename T>
+void BinarySearchTree<T>::insert(const T& newEntry)
+{
+    BinaryTreeNode<T>* newNodePtr = new BinaryTreeNode<T>(newEntry);
+    this->rootPtr = _insert(this->rootPtr, newNodePtr);
+    this->count++;
+}
+
+template<typename T>
+BinaryTreeNode<T>* BinarySearchTree<T>::_insert(BinaryTreeNode<T>* nodePtr, BinaryTreeNode<T>* newNodePtr) {
+    BinaryTreeNode<T>* pWalk = nodePtr, * parent = nullptr;
+
+    if (!nodePtr)
+    {
+        nodePtr = newNodePtr;
+        return nodePtr;
+    } else {
+        while (pWalk)
+        {
+            parent = pWalk;
+            if (pWalk->getItem() > newNodePtr->getItem())
+                pWalk = pWalk->getLeftPtr();
+            else
+                pWalk = pWalk->getRightPtr();
+        }
+        if (parent->getItem() > newNodePtr->getItem())
+            parent->setLeftPtr(newNodePtr);
+        else
+            parent->setRightPtr(newNodePtr);
+    }
+
+    return nodePtr;
+}
+
+template<typename T>
+bool BinarySearchTree<T>::search(const T& target, T& returnedItem) const
+{
+    BinarySearchTree<T>* temp = nullptr;
+
+    temp = _search(this->rootPtr, target);
+    if (temp) {
+        returnedItem = temp->getItem();
+        return true;
+    }
+
+    return false;
+}
+
+template<typename T>
+BinaryTreeNode<T>* BinarySearchTree<T>::_search(BinaryTreeNode<T>* nodePtr, const T& target) const
+{
+    BinaryTreeNode<T>* found = nullptr;
+
+    if (nodePtr) {
+        if (target.getCode() == nodePtr->getItem().getCode()) found = nodePtr;
+        else if (target.getCode() < nodePtr->getItem().getCode()) found = _search(nodePtr->getLeftPtr(), target);
+        else found = _search(nodePtr->getRightPtr(), target);
+    }
+
+    return found;
+}

BinarySearchTree.h

@@ -6,17 +6,18 @@
 template<typename T>
 class BinarySearchTree: public BinaryTree<T> {
 private:
+    BinaryTreeNode<T>* _insert(BinaryTreeNode<T>* nodePtr, BinaryTreeNode<T>* newNode);
+
+    BinaryTreeNode<T>* _search(BinaryTreeNode<T>* treePtr, const T& target) const;
+
+    //BinaryNode<ItemType>* _remove(BinaryNode<ItemType>* nodePtr, const ItemType target, bool& success);
 
 public:
-    BinarySearchTree() : BinaryTree<T>() {};
+    void insert(const T& item);
-
-    ~BinarySearchTree() { throw std::logic_error("Not implemented: ~BinarySearchTree()"); };
-
-    void insert(const T &item) { throw std::logic_error("Not implemented: BinarySearchTree.insert()"); };
 
     void remove(const T &item) { throw std::logic_error("Not implemented: BinarySearchTree.remove()"); };
 
-    BinaryTreeNode<T> *search(const T &item) { return _search(this->root, item); };
+    bool search(const T& target, T& returnedItem) const;
 };
 
 #endif //INC_08_TEAM_PROJECT_BINARYSEARCHTREE_H

BinaryTree.cpp

@@ -1 +1,56 @@
 #include "BinaryTree.h"
+
+template<class T>
+void BinaryTree<T>::destroyTree(BinaryTreeNode<T>* nodePtr)
+{
+    if (nodePtr) // != NULL
+    {
+        destroyTree(nodePtr->getLeftPtr());
+        destroyTree(nodePtr->getRightPtr());
+        delete nodePtr;
+    }
+}
+
+template<typename T>
+void BinaryTree<T>::_preorder(void visit(const T&), BinaryTreeNode<T>* nodePtr) const
+{
+	if (nodePtr) {
+		T item = nodePtr->getItem();
+		visit(item);
+		_preorder(visit, nodePtr->getLeftPtr());
+		_preorder(visit, nodePtr->getRightPtr());
+	}
+}
+
+template<typename T>
+void BinaryTree<T>::_inorder(void visit(const T&), BinaryTreeNode<T>* nodePtr) const
+{
+    if (nodePtr) // != NULL
+    {
+        T item = nodePtr->getItem();
+        _inorder(visit, nodePtr->getLeftPtr());
+        visit(item);
+        _inorder(visit, nodePtr->getRightPtr());
+    }
+}
+
+template<typename T>
+void BinaryTree<T>::_postorder(void visit(const T&), BinaryTreeNode<T>* nodePtr) const
+{
+    if (nodePtr) {
+        T item = nodePtr->getItem();
+        _postorder(visit, nodePtr->getLeftPtr());
+        _postorder(visit, nodePtr->getRightPtr());
+        visit(item);
+    }
+}
+
+template<typename T>
+void BinaryTree<T>::_printindented(void visit(const T&, int), BinaryTreeNode<T>* nodePtr) const {
+    if (nodePtr) {
+        T item = nodePtr->getItem();
+        _printInnerNodes(visit, nodePtr->getLeftPtr());
+        if (nodePtr->getLeftPtr() || nodePtr->getRightPtr()) visit(item);
+        _printInnerNodes(visit, nodePtr->getRightPtr());
+    }
+}

BinaryTree.h

@@ -5,28 +5,49 @@
 
 template<typename T>
 class BinaryTree {
-private:
+protected:
     BinaryTreeNode<T> *root;
     int size;
 
 public:
+
     BinaryTree() : root(nullptr), size(0) {};
 
-    ~BinaryTree() { throw std::logic_error("Not implemented: ~BinaryTree()"); };
+    BinaryTree(const BinaryTree<T>& tree) { }
+
+    ~BinaryTree() { destroyTree(root); };
 
     [[nodiscard]] bool isEmpty() const { return size == 0; };
 
     [[nodiscard]] int getSize() const { return size; };
 
-    void clear() { throw std::logic_error("Not implemented: BinaryTree.clear()"); };
+    void clear() { destroyTree(root); root = 0; size = 0; }
 
-    void preOrder(void visit(const T &)) { throw std::logic_error("Not implemented: BinaryTree.preOrder()"); };
+    void preOrder(void visit(const T&)) const { _preorder(visit, root); }
 
-    void postOrder(void visit(const T &)) { throw std::logic_error("Not implemented: BinaryTree.postOrder()"); };
+    void inOrder(void visit(const T&)) const { _inorder(visit, root); }
 
-    void inOrder(void visit(const T &)) { throw std::logic_error("Not implemented: BinaryTree.inOrder()"); };
+    void postOrder(void visit(const T&)) const { _postorder(visit, root); }
 
-    void printIndented(void visit(const T &, int)) { throw std::logic_error("Not implemented: BinaryTree.printIndented()"); };
+    void printIndented(void visit(const T&)) const { _printindented(visit, root, 0); }
+
+    // abstract functions to be implemented by derived class
+    virtual void insert(const T& newData) = 0;
+    //virtual bool remove(const T &data) = 0;
+    virtual bool search(const T& target, T& returnedItem) const = 0;
+
+private:
+    // delete all nodes from the tree
+    void destroyTree(BinaryTreeNode<T>* nodePtr);
+
+    // internal traverse
+    void _preorder(void visit(const T&), BinaryTreeNode<T>* nodePtr) const;
+
+    void _inorder(void visit(const T&), BinaryTreeNode<T>* nodePtr) const;
+
+    void _postorder(void visit(const T&), BinaryTreeNode<T>* nodePtr) const;
+
+    void _printindented(void visit(const T&, int), BinaryTreeNode<T>* nodePtr) const;
 
 };
 

BinaryTreeNode.h

@@ -5,6 +5,31 @@
 
 template<typename T>
 class BinaryTreeNode {
+private:
+    T item;        // Data portion
+    BinaryTreeNode<T>* leftPtr;     // Pointer to left child
+    BinaryTreeNode<T>* rightPtr;    // Pointer to right child
+
+public:
+    // constructors
+    BinaryTreeNode(const T& anItem) { item = anItem; leftPtr = 0; rightPtr = 0; }
+    BinaryTreeNode(const T& anItem,
+        BinaryTreeNode<T>* left,
+        BinaryTreeNode<T>* right) {
+        item = anItem; leftPtr = left; rightPtr = right;
+    }
+    // setters
+    void setItem(const T& anItem) { item = anItem; }
+    void setLeftPtr(BinaryTreeNode<T>* left) { leftPtr = left; }
+    void setRightPtr(BinaryTreeNode<T>* right) { rightPtr = right; }
+
+    // getters
+    T getItem() const { return item; }
+    BinaryTreeNode<T>* getLeftPtr() const { return leftPtr; }
+    BinaryTreeNode<T>* getRightPtr() const { return rightPtr; }
+
+    // other functions
+    bool isLeaf() const { return (leftPtr == 0 && rightPtr == 0); }
 
 };