BST.cpp

#include <iostream>
using namespace std;

class Node{
public:
    int data;
    Node *left;
    Node *right;

    Node(int data){
        this->data = data;
        left = right = nullptr;
    }
};

class BST{
    Node *root;
public:

    BST(){
        root = nullptr;
    }

    Node* insert(Node* pNode, int val){
        if (pNode == nullptr){
            return new Node(val);
        }
        if (val < pNode->data){
            pNode->left = insert(pNode->left,val);
        }
        else if (val > pNode->data){
            pNode->right = insert(pNode->right, val);

        }
        else {
            return pNode;
        }

        return pNode;
    }

    void insert(int val){
        root = insert(root, val);
    }

    void preoOrder(Node* pNode){
        if (pNode == nullptr){
            return;
        }
        cout << pNode->data << " ";
        preoOrder(pNode->left);
        preoOrder(pNode->right);
    }

    void inOrder(Node* pNode){
        if (pNode == nullptr){
            return;
        }
        inOrder(pNode->left);
        cout << pNode->data << " ";
        inOrder(pNode->left);
    }

    void postOrder(Node* pNode){
        if (pNode == nullptr){
            return;
        }
        postOrder(pNode->left);
        postOrder(pNode->left);
        cout << pNode->data << " ";
    }

    Node* saerch(Node* pNode, int val){
        if (pNode == nullptr){
            return nullptr;
        }
        else if(val == pNode->data){
            return pNode;
        }
        else if (val < pNode->data){
            return saerch(pNode->left,val);
        }
        else {
            return saerch(pNode->right,val);
        }
    }

    Node* findMin(Node* pNode){
        if (pNode == nullptr){
            return nullptr;
        }
        if (pNode->left == nullptr){
            return pNode;
        }
        else{
            return findMin(pNode->left);
        }
    }

    int getSum(Node* pNode){
        if (pNode == nullptr){
            return 0;
        }
        return pNode->data + getSum(pNode->left) + getSum(pNode->right);
    }

    int getNumberOfNodes(Node* pNode){
        if (pNode == nullptr){
            return 0;
        }
        return 1 + getNumberOfNodes(pNode->left) + getNumberOfNodes(pNode->right);
    }

    int getHeight(Node* pNode){
        if (pNode == nullptr){
            return -1;
        }
        int rightHeight = getHeight(pNode->right);
        int leftHeight = getHeight(pNode->left);

        return 1 + max(rightHeight,leftHeight);
    }

    Node* finMax(Node* pNode){
        if(pNode == nullptr){
            return nullptr;
        }
        else if (pNode->right == nullptr){
            return pNode;
        }
        else{
            return finMax(pNode->right);
        }
    }

    Node* Delete(Node* pNode, int val){
        if (pNode == nullptr){
            return nullptr;
        }
        else if (val < pNode->data){
            pNode->left =  Delete(pNode->left,val);
        }
        else if (val > pNode->data){
            pNode->right = Delete(pNode->right,val);
        }
        else {
            if (pNode->left == nullptr && pNode->right == nullptr){
                delete pNode;
                pNode = nullptr;
            }
            else if (pNode->left == nullptr && pNode->right != nullptr) {
                Node* temp = pNode->right;
                delete pNode;
                pNode = temp;
            }
            else if (pNode->left != nullptr && pNode->right == nullptr) {
                Node* temp = pNode->left;
                delete pNode;
                pNode = temp;
            }
            else {
                Node* min = findMin(pNode->right);
                pNode->data = min->data;
                pNode->right = Delete(pNode->right,min->data);
            }
        }
        return pNode;
    }

    int height(Node* node) {
        if (node == nullptr)
            return -1;  // height of empty tree is -1
        return 1 + max(height(node->left), height(node->right));
    }

    int countNodes(Node* node) {
        if (node == nullptr)
            return 0;
        return 1 + countNodes(node->left) + countNodes(node->right);
    }

    int

};

int main() {

    return 0;
}