bst min max cpp

// program to find the min and max element in bst


#include<iostream>

using namespace std;

class node{
    protected:
        int element;
        node* left;
        node* right;

    public:

        //constructor that accepts only element
        node(int element){
            this->element = element;
            this->left = NULL;
            this->right = NULL;
        }

        //constructor that accepts element, left Link, Right Link
        node(int element, node* leftLink, node* rightLink){
            this->element = element;
            this->left = leftLink;
            this->right = rightLink;
        }

        //method to update data of the node
        void updateData(int element){
            this->element = element;
        }

        //method to update the left Link of the node
        void updateLeftLink(node* temp){
            this->left = temp;
        }

        //method to update the right link of the node
        void updateRightLink(node* temp){
            this->right = temp;
        }

        //method that returns the element of the node
        int getElement(){
            return this->element;
        }

        //method that returns left Link
        node* getLeftNode(){
            return this->left;
        }

        //method that returns the right Link
        node* getRightNode(){
            return this->right;
        }
};

//binary search tree class
class BST{
    protected:
        node* root;

    public:

        //constructor for bst
        BST(){
            root = NULL;
        }

        //returns true if the root node is null
        bool isEmpty(){
            return(root == NULL);
        }

        //returns root node
        node* getRoot(){
            return root;
        }

        void insert(int element){
            node* temp = new node(element);
            //if tree is empty put it at root node
            if(root == NULL){
                root = temp;
            }
            else{
                bool inserted = false;
                //creating a node pointer to traverse the tree
                node* p = root;

                //keep looping while the node is not inserted
                while(not inserted){
                    //if element of the new node is less than the current node than insert it to the left
                    if(p->getElement() > temp->getElement()){
                        if(p->getLeftNode() == NULL){
                            p->updateLeftLink(temp);
                            inserted = true;
                        }
                        else{
                            p = p->getLeftNode();
                        }
                    }
                    //if element of the new node is greater than the current node than insert it to the right
                    else if(p->getElement() < temp->getElement()){
                        if(p->getRightNode() == NULL){
                            p->updateRightLink(temp);
                            inserted = true;
                        }
                        else{
                            p = p->getRightNode();
                        }
                    }
                }
            }
        }


        // method that returns max element of the binary search tree
        // max element appears in the right most node of the bst
        int Max(){
            if(isEmpty()){
                cout<<"The tree is empty!!";
                return -99999;      // assuming -99999 never appeares in the tree
            }
            else{
                // creating a temp node to traverse the tree
                node* tempNode = root;
                // keep traversing to the right node of the bst
                while(tempNode->getRightNode() != NULL){
                    tempNode = tempNode->getRightNode();
                }
                return tempNode->getElement();
            }
        }


        // method that returns min element of the binary search tree
        // max element appears in the left most node of the bst
        int Min(){
            if(isEmpty()){
                cout<<"The tree is empty!!";
                return 99999;       // assuming 99999 never appeares in the tree
            }
            else{
                // creating a temp node to traverse the tree
                node* tempNode = root;
                // keep traversing to the left node of the bst
                while(tempNode->getLeftNode() != NULL){
                    tempNode = tempNode->getLeftNode();
                }
                return tempNode->getElement();
            }
        }

};

int main()
{
    BST b1;
    b1.insert(7);
    b1.insert(29);
    b1.insert(25);
    b1.insert(36);
    b1.insert(71);
    b1.insert(24);
    b1.insert(5);
    b1.insert(9);
    b1.insert(1);

    node* root = b1.getRoot();
    cout<<"The Root element of the BST is : "<<root->getElement()<<endl;

    cout<<"\n\nThe Largest element of the BST is : "<<b1.Max();

    cout<<"\n\nThe Smallest element of the BST is : "<<b1.Min();
}