#pragma once

template <typename Comparable>
class BinarySearchTree
{
public:
    BinarySearchTree();
    BinarySearchTree(const BinarySearchTree &rhs);
    ~BinarySearchTree()
    {
        makeEmpty();
    }

    const Comparable &findMin() const;
    const Comparable &findMax() const;

    bool contains(const Comparable &x) const
    {
        return contains(x,root);
    }

    bool isEmpty() const;
    void printTree() const;

    void makeEmpty();

    void insert(const Comparable &x)
    {
        insert(x,root);
    }
    void remove(const Comparable &x)
    {
        remove(x,root);
    }

    const BinarySearchTree & operator= (const BinarySearchTree &rhs)
    {
        if(this != &rhs)
        {
            makeEmpty();
            root = clone(rhs.root);
        }
        reuturn *this;
    }

private:
    struct BinaryNode
    {
        Comparable element;
        BinaryNode *left;
        BinaryNode *right;

        BinaryNode(const Comparable & theElement,BinaryNode *lt,BinaryNode *rt)
            :element(theElement),left(lt),right(rt){ }
    };

    BinaryNode *root;

    void insert(const Comparable &x,BinaryNode *&t)const
    {
        if(t==NULL)
            t = new BinaryNode(x,NULL,NULL);
        else if(x<t->element)
            insert(x,t->left);
        else if(t->element<x)
            insert(x,t->right);
        else
            ;
    }

    void remove(const Comparable &x,BinaryNode *&t)const
    {
        if(t == NULL)
            return;
        if(x<t->element)
            remove(x,t->left);
        else if(t->element < x)
            remove(x,t->right);
        else if(t->left != NULL && t->right != NULL)
        {
            t->element = findMin(t->right)->element;
            remove(t->element,t->right);
        }
        else
        {
            BinaryNode *oldNode = t;
            t = (t->left != NULL) ? t->left:t->right;
            delete oldNode;
        }
    }

    BinaryNode * findMin(BinaryNode *t)const
    {
        if(t==NULL)
            return NULL;
        if(t->left ==NULL)
            return t;
        return findMin(t->left);
    }

    BinaryNode * findMax(BinaryNode *t)const
    {
        if(t != NULL)
            while(t->right != NULL)
                t = t->right;
        return t;
    }
    bool contains(const Comparable &x,BinaryNode *t)const
    {
        if(t == NULL)
            return false;
        else if(x<t->element)
            return contains(x,x->left);
        else if(t->element<x)
            return contains(x,t->right);
        else
            return true;
    }
    void makeEmpty(BinaryNode *&t)
    {
        if(t != NULL)
        {
            makeEmpty(t->left);
            makeEmpty(t->right);
            delete t;
        }
        t = NULL;
    }
    void printTree(BinaryNode *t)const
    {
        if(t != NULL)
        {
            //printf(t->element);
            printTree(t->left);
            printTree(t->right);
        }
    }
    BinaryNode * clone(BinaryNode *t)const
    {
        if(t == NULL)
            return NULL;
        return new BinaryNode(t->element,clone(t->left),clone(t->right));
    }
};