#ifndef BST_H
#define BST_H
template <class K, class D>
class TreeNode {
public:
    K key;
    D data;
    TreeNode *left;
    TreeNode *right;
    TreeNode *parentl;
    TreeNode *parentr;
    int level;
    TreeNode(K k, D d) {
        key = k;
        data = d;
        *left = null;
        *right = null;
        *parentl = null;
        *parentr = null;
        level = 0;
    }
};
#endif
//// BST.h header file
#include "BST.h"
#include <iostream>
template <class K, class D>
class BST {
public: BST() {
    *root = null;
}
private: TreeNode<K, D> *root;
public:
    bool IsEmpty() {
        if (*root == null) {
            return 1;
        }
        else return 0;
    }
    int GetHeight() {
        if (!this.IsEmpty()) {
        }
        else {
            return -1;
        }
    }
    void Inorder() {
        this->Inorder(*root);
    }
    void Preorder() {
        this->Preorder(*root);
    }
    void Postorder() {
        this->Postorder(*root);
    }
    void Levelorder() {
        this->Levelorder(*root);
    }
    void Insert(const K& key, const D& data) {
        this->Insert(*root, key, data);
    }
    void Remove(const K& key) {
        this->Remove(*root, key);
    }
    D Find(const K& key) {
        return this->Find(*root, key).data;
    }
private:
    void Inorder(TreeNode *&curr_node) {
        if (*curr_node == null) {}
        else {
            Inoder(*curr_node.left);
            std::cout << "<" << curr_node.key << "," << curr_node.data << ">" << endl;
            Inoder(*curr_node.right);
        }
    }
    void Preorder(TreeNode<K, D> *curr_node) {
        if (*curr_node == null) {}
        else {
            std::cout << "<" << curr_node.key << "," << curr_node.data << ">" << endl;
            Prenoder(*left);
            Preoder(*right);
        }
    }
    void Postorder(TreeNode<K, D> *curr_node) {
        if (*curr_node == null) {}
        else {
            Postnoder(*left);
            Postoder(*right);
            std::cout << "<" << curr_node.key << "," << curr_node.data << ">" << endl;
        }
    }
    void Levelorder(TreeNode<K, D> *curr_node) {
        if (*curr_node == null) {}
        else if (*left == null && *right == null) {
            std::cout << "<" << curr_node.key << "," << curr_node.data << ">" << endl;
        }
        else {
            Levelorder(*left);
            Levelorder(*right);
        }
    }
    TreeNode<K, D>* Find(TreeNode<K, D> *&curr_Node, const K& key) {
        if (*curr_Node == null) {
            return null;
        }
        else if (*curr_Node.key == key) {
            return *curr_Node;
        }
        else if (*curr_Node.key < key) {
            Find(*right, key);
        }
        else {
            Find(*left, key);
        }
    }
    void Insert(TreeNode<K, D> *&curr_node, const K& key, const D& data) {
        TreeNode<K, D> *tn = Find(*curr_node, key);
        if (*curr_node == null) {
            TreeNode<K, D> *ntn = TreeNode(key, data);
            root = ntn;
        }
        else if (*tn != null) {
            tn.data = data;
        }
        else if (*curr_node.key < key) {
            if (*(curr_node.right) == null) {
                TreeNode<K, D> *ntn = TreeNode(key, data);
                curr_node.right = ntn;
                ntn.parentl = curr_node;
                *ntn.level = *curr_node.level + 1;
            }
            else {
                Insert(*right, key, data);
            }
        }
        else {
            if (*(curr_node.left) == null) {
                TreeNode<K, D> *ntn = TreeNode(key, data);
                curr_node.left = ntn;
                ntn.parentr = curr_node;
                *ntn.level = *curr_node.level + 1;
            }
            else {
                Insert(*left, key, data);
            }
        }
    }
    TreeNode<K, D>*& RightMostChild(TreeNode<K, D> *&curr_Node) {
        while (*(curr_node.right) != null) {
            curr_node = curr_node.right;
        }
        return *curr_node;
    }
    void NoChildRemove(TreeNode<K, D> *&curr_node) {
        delete curr_node;
    }
    void OneChildRemove(TreeNode<K, D> *&curr_node) {
        if (*(curr_node.left) == null) {
            if (*(curr_node.parentl) == null) {
                *(curr_node.parentr).left = curr_node.right;
            }
            else {
                *(curr_node.parentl).right = curr_node.right;
            }
        }
        else {
            if (*(curr_node.parentl) == null) {
                curr_node.parentr.left = curr_node.left;
            }
            else {
                curr_node.parentl.right = curr_node.left;
            }
        }
        delete curr_node;
    }
    void TwoChildRemove(TreeNode<K, D> *&curr_node) {
        if (*(curr_node.parentl) == null) {
            curr_node.parentr.left = RightMostChild(curr_node);
        }
        else {
            curr_node.parentl.right = RightMostChild(curr_node);
        }
        delete curr_node;
    }
    void DoRemoval(TreeNode<K, D> *&curr_node) {
        if (*curr_node.left == null && *curr_node.right == null) {
            NoChildRemove(*curr_node);
        }
        else if (*curr_node.left == null || *curr_node.right == null) {
            OneChildRemove(*curr_node);
        }
        else {
            TwoChildRemove(*curr_node);
        }
    }
    void Remove(TreeNode<K, D> *&curr_node, const K& key) {
        DoRemoval(Find(*root, key));
    }
int main() {
        BST *test = new BST();
        test->Insert(1, 1.1);
        return 0;
    }
};
/// BST.cpp file
I have struggled with these two errors(LNK2019, LNK 1120) for two days...
I've searching about linker errors and tried everything I've found, but it's still not working
I checked my project option -> linker-> system -> subsystem is console
I'm sure my project is Win32 console application and my main() exists at the last part of my code.
I also tried rebooting my computer and reinstalling Visual Studio...
It just keep saying can't find main()...
How can I solve these errors? HELP ME