如何从嵌套类中访问指针？

Question

这个类的目的是模拟二叉搜索树的功能。在下面的代码中，我试图将它从一个结构和一堆函数改编为一个名为 BST 的包装类。但是，我不确定的一件事是如何从节点结构中访问“根”。 Root 当前在 BST 类中声明。

class bst
{
public:
struct Node
{
    public:
    int data;
    struct Node *left;
    struct Node *right;


    Node* FindMin(Node* root)
    {
        while(root->left != NULL) root = root->left;
        return root;
    }

    Node* Insert(Node *root,int data)
    {
        if(root == NULL) {
            root = new Node();
            root->data = data;
            root->left = root->right = NULL;

            //Update Height & Size
            bstHeight = 0;
            bstSize = 0;
        }
        else if(data <= root->data)
            root->left = Insert(root->left,data);
        else
            root->right = Insert(root->right,data);
        return root;

    }

    Node* Delete(struct Node *root, int data)
    {
        if(root == NULL) return root;
        else if(data < root->data) root->left = Delete(root->left,data);
        else if (data > root->data) root->right = Delete(root->right,data);
        //Value found
        else {
            // Case 1:  No child
            if(root->left == NULL && root->right == NULL)
            {
                delete root;
                root = NULL;

                //Update Height & Size
                bstHeight = 0;
                bstSize = 0;
            }
            //Case 2: One child
            else if(root->left == NULL)
            {
                struct Node *temp = root;
                root = root->right;
                delete temp;

                //Update Height & Size
                bstHeight = 0;
                bstSize = 0;
            }
            else if(root->right == NULL)
            {
                struct Node *temp = root;
                root = root->left;
                delete temp;

                //Update Height & Size
                bstHeight = 0;
                bstSize = 0;
            }
            // case 3: 2 children
            else
            {
                struct Node *temp = FindMin(root->right);
                root->data = temp->data;
                root->right = Delete(root->right,temp->data);

                //Update Height & Size
                bstHeight = 0;
                bstSize = 0;
            }
        }
        return root;
    }

    //# of Nodes in tree
    void size(Node *root)
    {
        //Check if end
        if(root == NULL) return;
        //Not end
        else
        {
            bstSize = bstSize + 1;
            size(root->left);       //Visit left subtree
            size(root->right);      // Visit right subtree

        }
    }

    void height(Node *root, int temp)
    {
        //Check if end
        if(root == NULL)
        {
            if(temp > bstHeight)
            {
                bstHeight = temp;
            }

            return;
        }

        //Not end
        else
        {
            temp = temp + 1;
            height(root->left, temp);       //Visit left subtree
            height(root->right, temp);      // Visit right subtree

        }
    }

    //Function to visit nodes in Inorder
    void show()
    {
        if(root == NULL) return;

        show(root->left);       //Visit left subtree
        printf("%d ",root->data);  //Print data
        show(root->right);      // Visit right subtree
    }

    void check(Node *root)
    {
        //End of a 'branch'
        if(root == NULL) return;

        int value = 0;
        value = root->data;

        //Checking left subtree
        if(value < root->left->data)
        {
            //Tree is NOT valid
            valid = 0;
        }

        //Checking right subtree
        if(value > root->right->data)
        {
            //Tree is NOT valid
            valid = 0;
        }

        check(root->left);       //Visit left subtree
        printf("%d ",root->data);  //Print data
        //check(root->right);      // Visit right subtree
    }

};
Node* root = NULL;
};

具体来说，在 show 函数中。这并不像把它和其他函数一起放到 Node 中那么简单，因为 root 需要是唯一的，并且 new Node 至少被调用一次。 Show 在当前状态下不会编译，我不知道从哪里开始。

Answer 1

虽然评论说明了一切，但让我提供一个额外的提示：

如果您想让您的代码尽可能地与您现在的代码相似，请尝试向 Node 类添加一个构造函数，该构造函数需要一个指向根的指针或引用（首选）并检查，每次创建一个节点，你把根给构造函数。

顺便说一句，在 C++ 中查看一些简单的基于节点的数据结构实现可能是一种更好的方法，例如在线程中

Simple linked list in C++