C++ 我不知道'；我不知道如何调用参数为节点类型的函数

我想在main（）中调用这个函数，但问题是当它接收节点类型参数时，我应该在其中传递什么参数 简单地说，我只想看看我的树的高度。因此，请帮助我，消除我在调用height函数时遇到的错误。它需要一个节点类型参数，我不知道应该传递什么。这是全部代码

#include <iostream>
using namespace std;
// Binary Search Tree
// 
class Node 
{
    public:
           int data;
           Node *left,*right;
           Node(Node *l=NULL ,int d=0, Node *r=NULL)
           {
            left=l;
            data=d;
            right=r;
           }
};

// Binary Search Tree
class Tree
{
  Node *root;

  public :
      Tree()
      {
        root=NULL;  
      } 

      bool isEmpty()
      {
        if(root==NULL)
          return true;
        else
          return false;  
      }
      /////////////////////////////////////////////////////////////////////////////////////////////////
      //  insert funcation
      /////////////////////////////////////////////////////////////////////////////////////////////////
      void insert(int val)
      {
        if(isEmpty())
        {
            root=new Node(NULL,val,NULL);

        }
        else if(val < root->data && root->left==NULL)
        {
            Node *p=new Node(NULL ,val,NULL);
            root->left=p;
        }   
        else if(val > root->data && root->right==NULL)
        {
            Node *p=new Node (NULL ,val,NULL);
            root->right=p;
        }

        else if(val < root->data)
        insert(val ,root->left);
        else 
        insert(val ,root->right);
      }
      ////////////////////////////////////////
      void insert(int val,Node *n)
      {
         if(val>n->data && n->right==NULL)
         {
           Node *p=new Node(NULL,val,NULL);
           n->right=p;  
         }
         else if(val > n->data)
           insert(val,n->right);
         else if(val <n->data && n->left==NULL)
         {
            Node *p=new Node(NULL,val,NULL);
            n->left=p;
         }
         else
          insert(val,n->left);
      }
      //////////////////////////////////////////////////////////////////////////////////////
      //   pre Order all data display
      //////////////////////////////////////////////////////////////////////////////////////

      void preOrder(void)
      {
        if(isEmpty())
        cout<<"Tree is Empty\n";
        else
            preOrder(root);
      }
      void preOrder(Node *n)
      {
        if(n!=NULL)
         {
            cout<<n->data<<endl;
            preOrder(n->left);
            preOrder(n->right);
        }
      }
      //////////////////////////////////////////////////////////////////////////////////////
      //         in fix Order all data display
      //////////////////////////////////////////////////////////////////////////////////////
      void inOrder()
      {
        if(isEmpty())
        cout<<"Tree is Empty\n";
        else
            inOrder(root);
      }
      void inOrder(Node *n)
      {
        if(n!=NULL)
         {
            inOrder(n->left);
            cout<<n->data<<endl;
            inOrder(n->right);
        }
      }
    //////////////////////////////////////////////////////////////////////////////////////
    //    post  Order all data display
    //////////////////////////////////////////////////////////////////////////////////////

      void posOrder()
      {
        if(isEmpty())
        cout<<"Tree is Empty\n";
        else
            posOrder(root);
      }
      void posOrder(Node *n)
      {
        if(n!=NULL)
         {
            posOrder(n->left);
            posOrder(n->right);
            cout<<n->data<<endl;
        }
      } 

      /////////////////////////////////////////////////////////////////////////////////////////////////
      //                    Search funcation
      /////////////////////////////////////////////////////////////////////////////////////////////////
      void search(int val)
      {
        if(isEmpty())
                   cout<<"Tree is Empty\n";
        else
           search(val,root);
      }
      void search(int v,Node *p)
      {    
           if(v==p->data)
                  cout<<"val : "<<p->data<<endl;        
           else if(v < p->data && p->left!=NULL)
                  search(v,p->left);
           else if(v>p->data && p->right!=NULL)
                search(v,p->right);
           else 
                  cout<<"Data Not Found \n";
      } 

     Node *l;
     int deleteKey(int val)
     {
      if(isEmpty())
      cout<<"Tree is Empty\n";
      else if(root->data==val &&(root->left==NULL&&root->right==NULL))
      {
         int temp=root->data;
         delete root;
         return temp;   
      }
       else
        deleteKey(val,root);
      }

       int deleteKey(int v,Node *p)
      {  
           if(v == p->data)  
             {

                  if(p->left==NULL && p->right==NULL)
                  {
                    if(l->right==p)  
                    {
                      int temp=p->data;
                      delete p;
                      l->right=NULL;
                      return temp;
                    }
                     else 
                     {
                      int temp=p->data;
                      delete p;
                      l->left=NULL;
                      return temp;
                     }
                  }
                  else if(p->right!=NULL) 
                  {
                      int temp=p->data;
                     deleteKey(p,p->right);
                     return temp;
                  }
                  else  
                  {
                    int temp=p->data;
                        cout<<"Left : "<<p->data<<endl;
                    deleteKey(p,p->left,v);
                    return temp;
                  }
             }
           else if(v < p->data && p->left!=NULL)
           {
                  l=p;
                  deleteKey(v,p->left);
           }
           else if(v>p->data &&p->right!=NULL)
           {    
                  l=p; 
                deleteKey(v,p->right);
           }
           else 
                  cout<<"Data Not Found ----\n";
      }

       int deleteKey(Node *find ,Node *next)
      {
            if( next->left == NULL && next->right != NULL ) 
            {
                find->data = next->data;
                deleteKey(find->right , next->right);
            }
            else if( next->left == NULL&& next->right==NULL)
            {
                find->data = next->data;
                delete next;
                find->right=NULL;
            }
            else  
            {
                Node *q;
                while(next->left!=NULL)
                {
                   q=next;  
                   next=next->left;
                 }
                 find->data=next->data;
                 delete next;
                 q->left=NULL;  
             }
      }
          int deleteKey(Node* find,Node *next,int v)
      {
            if( next->right == NULL && next->left != NULL ) 
            {
                find->data = next->data;
                deleteKey(find->left , next->left,v);
            }
            else if( next->right == NULL&& next->left==NULL)
            {
                find->data = next->data;
                delete next;
                find->left=NULL;
            }
            else 
            {
                Node *q;
                while(next->right!=NULL)
                {
                   q=next;  
                   next=next->right;
                 }
                 find->data=next->data;
                 delete next;
                 q->right=NULL; 
             }
      }

       ~Tree()
       {
         dist();
       }

             void dist()
             {
                dist(root);
             }
              void dist(Node *n)
              {
                if(n!=NULL)
                {
                     dist(n->left);
                     dist(n->right);
                     delete n;
               }
             }
             int height(Node *root)
             {
                int h=0;
                if (isEmpty())
                {
                    cout<<"Tree is Empty\n";    
                }
                else
                {
                    int left_height=height(root->left);
                    int right_height=height(root->right);
                    h=1+max(left_height, right_height);

                }
                return h;
             }

};

int main()
{
    Tree obj;
    obj.height();   
}

#包括
使用名称空间std；
//二叉搜索树
// 
类节点
{
公众：
int数据；
节点*左，*右；
节点（节点*l=NULL，int d=0，节点*r=NULL）
{
左=l；
数据=d；
右=r；
}
};
//二叉搜索树
类树
{
节点*根；
公众：
树（）
{
root=NULL；
} 
布尔是空的
{
if（root==NULL）
返回true；
其他的
返回false；
}
/////////////////////////////////////////////////////////////////////////////////////////////////
//插入函数
/////////////////////////////////////////////////////////////////////////////////////////////////
无效插入（int val）
{
if（isEmpty（））
{
root=新节点（NULL、val、NULL）；
}
else if（valdata&&root->left==NULL）
{
Node*p=新节点（NULL，val，NULL）；
根->左=p；
}   
else if（val>root->data&&root->right==NULL）
{
Node*p=新节点（NULL，val，NULL）；
根->右=p；
}
else if（valdata）
插入（val，root->left）；
其他的
插入（val，root->right）；
}
////////////////////////////////////////
无效插入（int val，节点*n）
{
如果（val>n->data&&n->right==NULL）
{
Node*p=新节点（NULL，val，NULL）；
n->right=p；
}
否则如果（val>n->data）
插入（val，n->右侧）；
else if（val data&&n->left==NULL）
{
Node*p=新节点（NULL，val，NULL）；
n->左=p；
}
其他的
插入（val，n->左）；
}
//////////////////////////////////////////////////////////////////////////////////////
//预购所有数据显示
//////////////////////////////////////////////////////////////////////////////////////
作废预订单（作废）
{
if（isEmpty（））
coutleft=NULL；
返回温度；
}
}
else if（p->right！=NULL）
{
int temp=p->data；
删除键（p，p->右）；
返回温度；
}
其他的
{
int temp=p->data；
coutp->data&&p->right！=NULL）
{    
l=p；
删除键（v，p->右侧）；
}
其他的
coutright！=NULL）
{
查找->数据=下一步->数据；
deleteKey（查找->右侧，下一步->右侧）；
}
else if（下一步->左==NULL&&next->右==NULL）
{
查找->数据=下一步->数据；
删除下一步；
find->right=NULL；
}
其他的
{
节点*q；
while（下一步->左！=NULL）
{
q=下一个；
下一步=下一步->左；
}
查找->数据=下一步->数据；
删除下一步；
q->left=NULL；
}
}
int deleteKey（节点*find，节点*next，int v）
{
如果（下一步->右==NULL&&next->左！=NULL）
{
查找->数据=下一步->数据；
deleteKey（查找->左，下一步->左，v）；
}
else if（下一步->右==NULL&&next->左==NULL）
{
查找->数据=下一步->数据；
删除下一步；
查找->左=空；
}
其他的
{
节点*q；
while（下一步->右！=NULL）
{
q=下一个；
下一步=下一步->右；
}
查找->数据=下一步->数据；
删除下一步；
q->right=NULL；
}
}
~Tree（）
{
dist（）；
}
空区（）
{
根区；
}
无效距离（节点*n）
{
如果（n！=NULL）
{
距离（n->左）；
距离（n->右）；
删除n；
}
}
整数高度（节点*根）
{
int h=0；
if（isEmpty（））
{
库特里赫特）；
h=1+最大值（左高、右高）；
}
返回h；
}
};
int main（）
{
树obj；
物体高度（）；
}

您必须在这个函数中传递树的根，但是更好的方法是，如果您在不带任何参数的情况下再生成一个函数，并将该函数设置为公共函数，然后通过传递这个->根来调用这个私有函数

在这里你可以看到：

public:
int getHeight()
{
return height(this->root); //pass your Tree class root
}

为了提高效率，在课堂上将该功能设置为私有

private:
int height(Node *root)
             {
                int h=0;
                if (isEmpty())
                {
                    cout<<"Tree is Empty\n";    
                }
                else
                {
                    int left_height=height(root->left);
                    int right_height=height(root->right);
                    h=1+max(left_height, right_height);

                }
                return h;
             }

private：
整数高度（节点*根）
{
int h=0；
if（isEmpty（））
{
库特里赫特）；
h=1+最大值（左高、右高）；
}
返回h；
}

另一种方法是在类中生成一个getRoot（）函数，在main中获取树类的根并传递给height函数。但是第一种方法会更好。

先生，我称之为