binary_tree.hpp

#include <memory>
#include <iostream>
 
template<class T>
class BSTree {
private:
    template<class N>
    class BSTNode {
    public:
        N data; 
        std::unique_ptr<BSTNode<N>> left; 
        std::unique_ptr<BSTNode<N>> right; 
    };
public:
    std::unique_ptr<BSTNode<T>> root;
 
    virtual void insert(const T& value) {
        std::unique_ptr<BSTNode<T>> node = std::make_unique<BSTNode<T>>();
        node->data = value;
 
        root = insertHelper(root, node);
    }
 
    virtual void display(const bool& ascOrder = true) {
        displayHelper(root, ascOrder);
    }
 
    virtual bool search(const T& data){
        return searchHelper(root, data);
    }
 
    virtual void remove() {
 
    }
 
private:
    virtual std::unique_ptr<BSTNode<T>> insertHelper(std::unique_ptr<BSTNode<T>>& root, std::unique_ptr<BSTNode<T>>& node) {
        T data = node->data;
 
        if (root == nullptr) {
            root = std::move(node);
            return std::move(root);
        }
        else if (data < root->data) {
            root->left = insertHelper(root->left, node);
        }
        else {
            root->right = insertHelper(root->right, node);
        }
        
        return std::move(root);
    }
 
    static void displayHelper(std::unique_ptr<BSTNode<T>>& root, const bool& ascendingOrder = true) {
        if(ascendingOrder) {
            if (root) {
                displayHelper(root->left);
                std::cout << root->data << std::endl;
                displayHelper(root->right);
            }
        }
        else{
            if (root) {
                displayHelper(root->right, ascendingOrder);
                std::cout << root->data << std::endl;
                displayHelper(root->left, ascendingOrder);
            }
        }
    }
 
    virtual bool searchHelper(std::unique_ptr<BSTNode<T>>& root, const T& data) {
        if(!root){
            return false;
        }
        else if(root->data == data){
            return true;
        }
        else if(root->data > data){
            return searchHelper(root->left, data);
        }
        else if(root->data < data){
            return searchHelper(root->right, data);
        }
 
        return false;
    }
 
    virtual void removeHelper() {
 
    }
 
    T successor(){
 
    }
 
    T predecessor(){
 
    }
};
 
void UsingBST();