从Tree类外部进行AVL Tree遍历

Question

我在使用C ++编写的Tree比较程序时遇到了一些麻烦。我试图遍历一个树来比较来自比较器类的另一个树中的元素，我收到一个错误，说我无法访问AVL树类中的root。我得到的错误是：'class avlTree'没有名为'root'的成员。下面是我所讨论方法的代码，之后是AVL Tree类。我开始怀疑是否应该在方法调用中将第二个树传递给AVL Tree类中的方法，然后遍历树，并从Tree类中调用第二个树。我是C ++的初学者，所以我提前为任何混乱和/或糟糕的风格道歉。

方式

void findCommon(){
if(tree.root == NULL){
  return;
}
findCommon(tree.root->left);
if (tree2.find(tree.root) == true){
  cout<<tree.root->data<<" ";
}
findCommon(tree.root->right);

}

AVL树类

#include<iostream>
#include<cstdio>
#include<sstream>
#include<algorithm>
#include<string>
#define pow2(n) (1 << (n))
using namespace std;

/*
* Node Declaration
*/
struct avl_node
{
  string data;
  struct avl_node *left;
  struct avl_node *right;
}*root;

/*
* Class Declaration
*/
class avlTree
{
public:

  avlTree()
  {
    root = NULL;
  }


  /*
  * Height of AVL Tree
  */
  int height(avl_node *temp)
  {
    int h = 0;
    if (temp != NULL)
    {
      int l_height = height (temp->left);
      int r_height = height (temp->right);
      int max_height = max (l_height, r_height);
      h = max_height + 1;
    }
    return h;
  }

  /*
  * Height Difference
  */
  int diff(avl_node *temp)
  {
    int l_height = height (temp->left);
    int r_height = height (temp->right);
    int b_factor= l_height - r_height;
    return b_factor;
  }

  /*
  * Right- Right Rotation
  */
  avl_node* rr_rotation(avl_node *parent)
  {
    avl_node* temp;
    temp = parent->right;
    parent->right = temp->left;
    temp->left = parent;
    return temp;
  }
  /*
  * Left- Left Rotation
  */
  avl_node* ll_rotation(avl_node *parent)
  {
    avl_node* temp;
    temp = parent->left;
    parent->left = temp->right;
    temp->right = parent;
    return temp;
  }

  /*
  * Left - Right Rotation
  */
  avl_node* lr_rotation(avl_node *parent)
  {
    return parent;
  }

  /*
  * Right- Left Rotation
  */
  avl_node* rl_rotation(avl_node *parent)
  {
    return parent;
  }

  /*
  * Balancing AVL Tree
  */
  avl_node* balance(avl_node *temp)
  {
    int bal_factor = diff (temp);
    if (bal_factor > 1)
    {
      if (diff (temp->left) > 0)
      temp = ll_rotation (temp);
      else
      temp = lr_rotation (temp);
    }
    else if (bal_factor < -1)
    {
      if (diff (temp->right) > 0)
      temp = rl_rotation (temp);
      else
      temp = rr_rotation (temp);
    }
    return temp;
  }

  /*
  * Insert Element into the tree
  */
  avl_node* insert(avl_node *root, string value)
  {
    if (root == NULL)
    {
      root = new avl_node;
      root->data = value;
      root->left = NULL;
      root->right = NULL;
      return root;
    }
    else if (value < root->data)
    {
      root->left = insert(root->left, value);
      root = balance (root);
    }
    else if (value >= root->data)
    {
      root->right = insert(root->right, value);
      root = balance (root);
    }
    return root;
  }

avl_node * minValueNode(avl_node* node)
{
    avl_node* current = node;

    /* loop down to find the leftmost leaf */
    while (current->left != NULL)
        current = current->left;

    return current;
}
bool find(avl_node* root, string data)
{
    // STEP 1: PERFORM STANDARD BST DELETE

    if (root == NULL)
        return false;
    // If the data to be deleted is smaller than the
    // root's data, then it lies in left subtree
    if ( data < root->data ){
      return find(root->left, data);
    }
    // If the data to be deleted is greater than the
    // root's data, then it lies in right subtree
    else if( data > root->data ){
        return find(root->right, data);
      }
    else
    {
        return true;
      }
}
  // Recursive function to delete a node with given data
// from subtree with given root. It returns root of
// the modified subtree.
avl_node* pick(avl_node* root, string data)
{
    // STEP 1: PERFORM STANDARD BST DELETE

    if (root == NULL)
        return root;

    // If the data to be deleted is smaller than the
    // root's data, then it lies in left subtree
    if ( data < root->data )
        root->left = pick(root->left, data);

    // If the data to be deleted is greater than the
    // root's data, then it lies in right subtree
    else if( data > root->data )
        root->right = pick(root->right, data);

    // if data is same as root's data, then This is
    // the node to be deleted
    else
    {
        // node with only one child or no child
        if( (root->left == NULL) || (root->right == NULL) )
        {
            avl_node *temp = root->left ? root->left :
                                             root->right;

            // No child case
            if (temp == NULL)
            {
                temp = root;
                root = NULL;
            }
            else // One child case
             *root = *temp; // Copy the contents of
                            // the non-empty child
            free(temp);
        }
        else
        {
            // node with two children: Get the inorder
            // successor (smallest in the right subtree)
            avl_node* temp = minValueNode(root->right);

            // Copy the inorder successor's data to this node
            root->data = temp->data;

            // Delete the inorder successor
            root->right = pick(root->right, temp->data);
        }
    }

    // If the tree had only one node then return
    if (root == NULL)
      return root;

    // STEP 2: UPDATE HEIGHT OF THE CURRENT NODE
    //root->height = 1 + max(height(root->left),
      //                     height(root->right));

    // STEP 3: GET THE BALANCE FACTOR OF THIS NODE (to
    // check whether this node became unbalanced)
    balance(root);

    return root;
}
  void inOrder(avl_node *root){
    if(root == NULL){
      return;
    }
    inOrder(root->left);
    cout<<root->data<<" ";
    inOrder(root->right);
  }
};