binary search tree

using namespace std;
template <typename T>
class TreeNode{
public:
    TreeNode* left;
    TreeNode* right;
    T value;
    TreeNode(T key): value(key), left(NULL), right(NULL){};
    TreeNode(T key, TreeNode* l, TreeNode* r): value(key), left(l), right(r){};
};
template <typename T>
class BSTree{
public:
    BSTree() = default;
    BSTree(TreeNode<T>* node): root(node) {};
    ~BSTree(){};
    void ();
    void inOrder();
    void postOrder();
    void insert(T value);
//    void insert(TreeNode* node);
    void search(T value);
//    void del(T value);
    bool empty();
    TreeNode<T>* getMin();
    TreeNode<T>* getMax();
private:
    TreeNode<T>* root;
    void (TreeNode<T>* const node) const;
    void inOrder(TreeNode<T>* const node) const;
    void postOrder(TreeNode<T>* const node) const;
    void search(TreeNode<T>* node, T key);
    TreeNode<T>* getMin(TreeNode<T>* const node);
    TreeNode<T>* getMax(TreeNode<T>* const node);
    bool empty(TreeNode<T>* node);
    void insert(TreeNode<T>* node, T value);
};
template <typename T>
void BSTree<T>::preOrder(TreeNode<T>* const node) const {
    if (node) {
        cout << node->value << endl;
        preOrder(node->left);
        preOrder(node->right);
    }else{
        return;
    }
}
template <typename T>
void BSTree<T>::preOrder() {
    preOrder(root);
}
template <typename T>
void BSTree<T>::inOrder(TreeNode<T>* const node) const {
    if (node){
        inOrder(node->left);
        cout << node->value << endl;
        inOrder(node->right);
    }else{
        return;
    }
}
template <typename T>
void BSTree<T>::inOrder() {
    inOrder(root);
}
template <typename T>
void BSTree<T>::postOrder(TreeNode<T>* const node) const {
    if (node){
        postOrder(node->left);
        postOrder(node->right);
        cout << node->value << endl;
    }else{
        return;
    }
}
template <typename T>
void BSTree<T>::postOrder() {
    postOrder(root);
}
template <typename T>
void BSTree<T>::search(TreeNode<T> * node, T value) {
    if (!node) {
        if (value == node->value) {
            cout << "the value is in this tree" << endl;
            return;
        }
        if (value > node->value)
            search(node->right, value);
        if (value < node->value)
            search(node->left, value);
    }
    return;
}
template <typename T>
void BSTree<T>::search(T value) {
    search(root, value);
}
template <typename T>
TreeNode<T>* BSTree<T>::getMin(TreeNode<T> *const node) {
    TreeNode<T>* tmp = node;
    while(tmp->left){
        tmp = tmp->left;
    }
    return tmp;
}
template <typename T>
TreeNode<T>* BSTree<T>::getMin() {
    getMin(root);
}
template <typename T>
TreeNode<T>* BSTree<T>::getMax(TreeNode<T> *const node) {
    TreeNode<T>* tmp = node;
    while(tmp->right){
        tmp = tmp->right;
    }
    return tmp;
}
template <typename T>
TreeNode<T>* BSTree<T>::getMax() {
    getMax(root);
}
template <typename T>
bool BSTree<T>::empty(TreeNode<T>* node){
    return node == NULL;
}
template <typename T>
bool BSTree<T>::empty(){
    return empty(root);
}
template <typename T>
void BSTree<T>::insert(TreeNode<T>* node, T value) {
    if (node == NULL){
        TreeNode<T>* tmp = new TreeNode<T>(value);
        node = tmp;
    }
    if (node->value > value){
        if (node->left == NULL){
            TreeNode<T>* tmp = new TreeNode<T>(value);
            node->left = tmp;
        }else{
            insert(node->left, value);
        }
    }else{
        if (node->right == NULL){
            TreeNode<T>* tmp = new TreeNode<T>(value);
            node->right = tmp;
        }else{
            insert(node->right, value);
        }
    }
}
template <typename T>
void BSTree<T>::insert(T value) {
    insert(root, value);
}