C++ 二叉搜索树在C++； #包括 使用名称空间std； 类节点{ 公众： int数据； 节点*左_子节点； 节点*右\子节点； 节点（int x）{ 数据=x； left_child=NULL； 右_child=NULL； } }; BST级{ 公众： //最初root为null Node*root=NULL； 无效插入（节点*节点，整数数据）{ if（node==NULL）{ 节点=新节点（数据）； 回来 } if（数据数据）{ 插入（节点->左\子节点，数据）； } else if（数据>节点->数据）{ 插入（节点->右\子节点，数据）； } } void just_insert（整数数据）{ 插入（根，数据）； } 无效打印（节点*节点）{ if（node==NULL）{ 回来 } cout>n； BST BST=BST（）； 对于（int i=0；i>x； bst.just_插入（x）； } bst.just_print（）； 返回0； }

BST的这种实现有什么问题？我给出了8个值作为输入： 8. 3. 5. 1. 6. 8. 7. 2. 4. 但是当我调用print函数时，我没有得到任何输出。 我是否遗漏了一些指针逻辑？insert函数递归地沿着树向下，以找到插入值的位置

---

打印函数也可以递归工作。

您从未在BST类中分配给root，因为您在insert函数外部看不到对insert类中节点的分配。您可以通过引用insert函数传递节点指针来解决此问题：

#include <iostream>
using namespace std;

class Node{
    public:
        int data;
        Node* left_child;
        Node* right_child;
        Node(int x){
            data = x;
            left_child = NULL;
            right_child = NULL;
        }
};

class BST{
    public:
    //Initially root is null
    Node* root = NULL;

    void insert(Node* node, int data){
        if(node == NULL){
            node = new Node(data);
            return;
        }
        if(data < node->data){
            insert(node->left_child,data);
        }
        else if(data > node->data){
            insert(node->right_child,data);
        }

    }
    void just_insert(int data){
        insert(root,data);
    }
    void print(Node* node){
        if(node == NULL){
            return;
        }
        cout<<node->data<<" ";
        print(node->left_child);
        print(node->right_child);
    }
    void just_print(){
        print(root);
    }
};

int main() {
    //For fast IO
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n,x;
    cin>>n;
    BST bst = BST();
    for(int i=0; i<n; i++){
        cin>>x;
        bst.just_insert(x);
    }
    bst.just_print();
    return 0;
}

void insert(Node*& node, int data)

---

您从未在BST类中分配给root，因为您在insert类中对节点的分配在insert函数外部不可见。您可以通过引用insert函数传递节点指针来解决此问题：

#include <iostream>
using namespace std;

class Node{
    public:
        int data;
        Node* left_child;
        Node* right_child;
        Node(int x){
            data = x;
            left_child = NULL;
            right_child = NULL;
        }
};

class BST{
    public:
    //Initially root is null
    Node* root = NULL;

    void insert(Node* node, int data){
        if(node == NULL){
            node = new Node(data);
            return;
        }
        if(data < node->data){
            insert(node->left_child,data);
        }
        else if(data > node->data){
            insert(node->right_child,data);
        }

    }
    void just_insert(int data){
        insert(root,data);
    }
    void print(Node* node){
        if(node == NULL){
            return;
        }
        cout<<node->data<<" ";
        print(node->left_child);
        print(node->right_child);
    }
    void just_print(){
        print(root);
    }
};

int main() {
    //For fast IO
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n,x;
    cin>>n;
    BST bst = BST();
    for(int i=0; i<n; i++){
        cin>>x;
        bst.just_insert(x);
    }
    bst.just_print();
    return 0;
}

void insert(Node*& node, int data)

---

让我们看看

insert

函数中的这些行：

#include <iostream>
using namespace std;

class Node{
    public:
        int data;
        Node* left_child;
        Node* right_child;
        Node(int x){
            data = x;
            left_child = NULL;
            right_child = NULL;
        }
};

class BST{
    public:
    //Initially root is null
    Node* root = NULL;

    void insert(Node* node, int data){
        if(node == NULL){
            node = new Node(data);
            return;
        }
        if(data < node->data){
            insert(node->left_child,data);
        }
        else if(data > node->data){
            insert(node->right_child,data);
        }

    }
    void just_insert(int data){
        insert(root,data);
    }
    void print(Node* node){
        if(node == NULL){
            return;
        }
        cout<<node->data<<" ";
        print(node->left_child);
        print(node->right_child);
    }
    void just_print(){
        print(root);
    }
};

int main() {
    //For fast IO
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n,x;
    cin>>n;
    BST bst = BST();
    for(int i=0; i<n; i++){
        cin>>x;
        bst.just_insert(x);
    }
    bst.just_print();
    return 0;
}

void insert(Node*& node, int data)

这里的问题是，参数

节点

是按值传递的，与任何其他局部变量类似，并且与任何其他局部变量一样，一旦函数返回，它将超出范围，并且对变量的所有更改都将丢失

您需要的是通过引用传递指针，如

---

让我们看看

insert

函数中的这些行：

#include <iostream>
using namespace std;

class Node{
    public:
        int data;
        Node* left_child;
        Node* right_child;
        Node(int x){
            data = x;
            left_child = NULL;
            right_child = NULL;
        }
};

class BST{
    public:
    //Initially root is null
    Node* root = NULL;

    void insert(Node* node, int data){
        if(node == NULL){
            node = new Node(data);
            return;
        }
        if(data < node->data){
            insert(node->left_child,data);
        }
        else if(data > node->data){
            insert(node->right_child,data);
        }

    }
    void just_insert(int data){
        insert(root,data);
    }
    void print(Node* node){
        if(node == NULL){
            return;
        }
        cout<<node->data<<" ";
        print(node->left_child);
        print(node->right_child);
    }
    void just_print(){
        print(root);
    }
};

int main() {
    //For fast IO
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int n,x;
    cin>>n;
    BST bst = BST();
    for(int i=0; i<n; i++){
        cin>>x;
        bst.just_insert(x);
    }
    bst.just_print();
    return 0;
}

void insert(Node*& node, int data)

这里的问题是，参数

节点

是按值传递的，与任何其他局部变量类似，并且与任何其他局部变量一样，一旦函数返回，它将超出范围，并且对变量的所有更改都将丢失

您需要的是通过引用传递指针，如