我试图实现一个二分搜索树的功能，如删除一个节点，找到最小节点，最大节点等，但我不能删除一个节点，也不能在树中找到最大或最小值。 我的看法是，当我插入节点时，指向节点的指针引用最后一个节点，因此我的程序不能从根节点迭代。 有什么建议吗？

 #include<iostream>
   using namespace std;

    struct BstNode
    {
        BstNode* left;
    BstNode* right;
    int data;   
};

BstNode* GetnewNode(int data)
{
    BstNode* newNode=new BstNode();
    
    newNode->data=data;
    newNode->left=NULL;
    newNode->right=NULL;
    
    return newNode;
     
} 

BstNode* Insert(BstNode* root ,int data)
{
    if(root==NULL)
    {
        root=GetnewNode(data);
    }
    else if(data<=root->data)
    {
        root=Insert(root->left,data);
    }
    else
    {
        root=Insert(root->right,data);
    }
    
    return root;
}   

bool Search(BstNode* root, int data)
{
    if(root==NULL)
    {
        return false;
    }
    else if(data==root->data)
    {
        return true;
    }
    else if(data<=root->data)
    {
        return Search(root->left,data);
    }
    else
    {
        return Search(root->right,data);
    }
}

int FindMin(BstNode* root)
{
    if(root==NULL)
    {
        return -1;
    }
    else
    {
        while(root->left!=NULL)
        {
            root=root->left;
        }
    }
    
    return root->data;
    
    
}
bool IsBstUtil(BstNode* root, int minvalue, int maxvalue)
{
    if(root==NULL)
    return true;
    
    if(root->data<minvalue && root->data >maxvalue && IsBstUtil(root->left,minvalue,root->data) && IsBstUtil(root->right,root->data,maxvalue))
    {
        return true;
    }
    else
    {
        return false;
    }
}

bool IsBinarySearchTree(BstNode* root)
{
    return IsBstUtil(root, INT_MIN, INT_MAX);
}

int FindMax(BstNode* root)
{
    if(root==NULL)
    {
        return -1;
        
    }
    else
    {
        while(root->right!=NULL)
        {
            root=root->right;
        }
    }
    
    return root->data;
}
BstNode* del(BstNode* root, int data)
{
    if(root==NULL)
        return root;
    else if(data<=root->data)
        root->left=del(root->left,data);
    else if(data>root->data)
        root->right=del(root->right,data);
    
    else
    {
        if(root->left==NULL && root->right==NULL)
        {   
            root=NULL;
            delete root;
        }
        else if(root->left==NULL)
        {
            BstNode* temp=root;
            root=root->right;
            delete temp;
            return root;
        }
        else if(root->right==NULL)
        {
            BstNode* temp=root;
            root=root->left;
            delete temp;
            return root;
        }
    }
}

int main()
{
    BstNode* root=NULL;
    root=Insert(root,1);
    root=Insert(root,3);
    root=Insert(root,4);
    
}