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

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函数中。它不像把它和其他函数放在节点中那样简单，因为根需要是唯一的，并且新节点至少被调用一次。Show将不会在当前状态下编译，我不确定从这里开始。

Answer 1

尽管这条评论说明了一切，但让我给出一个额外的提示：

当你想让你的代码尽可能与现在的代码相似时，试着向Node类添加一个构造函数，该构造函数需要一个指向根的指针或引用（最好是这样），并检查每次你创建一个节点时，你是否将根交给了构造函数。

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

C语言中的简单链表