Java二叉搜索树开发：如何通过用户输入添加非原始数据类型的值？

先解决你当前的报错：int无法转换为Node #

你遇到的报错核心是insert方法的参数类型不匹配——你的insert方法要求传入Node对象，但你直接把scanner.nextInt()返回的int值传了进去，自然会报类型转换错误。解决方法有两种：

方法1：先把int包装成Node再传入 #

假设你的Node类定义是这样的：

class Node {
    int data;
    Node left;
    Node right;

    Node(int data) {
        this.data = data;
        left = right = null;
    }
}

那你需要先用用户输入的int创建Node对象，再传给insert：

Scanner scanner = new Scanner(System.in);
int inputNum = scanner.nextInt();
Node newNode = new Node(inputNum);
yourBST.insert(newNode); // yourBST是你的BST实例

方法2：修改insert方法，让它直接接受数据值 #

更合理的做法是让insert方法接受具体的数据（比如int），内部自行创建Node。示例代码：

public class BinarySearchTree {
    private Node root;

    class Node {
        int data;
        Node left, right;
        Node(int data) { this.data = data; }
    }

    // 对外暴露的insert方法，接受int值
    public void insert(int data) {
        root = insertRecursive(root, data);
    }

    // 内部递归插入逻辑
    private Node insertRecursive(Node current, int data) {
        if (current == null) {
            return new Node(data);
        }
        if (data < current.data) {
            current.left = insertRecursive(current.left, data);
        } else if (data > current.data) {
            current.right = insertRecursive(current.right, data);
        }
        return current;
    }
}

这样调用时直接传scanner.nextInt()就不会报错：

yourBST.insert(scanner.nextInt());

如何通过用户输入添加非原始类型的值？ #

当然可以，只要让你的BST支持泛型，同时处理好自定义类型的比较和输入解析，步骤如下：

1. 定义实现Comparable接口的自定义类 #

BST需要根据节点值的大小确定插入位置，所以自定义类必须实现Comparable接口，重写compareTo方法定义比较规则。比如我们定义一个Person类：

class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 按年龄比较大小，也可以改成按姓名排序
    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }

    // 重写toString方便后续打印输出
    @Override
    public String toString() {
        return "姓名：" + name + "，年龄：" + age;
    }
}

2. 改造BST为泛型类 #

让BST支持任意实现了Comparable的类型：

class BinarySearchTree<T extends Comparable<T>> {
    private Node<T> root;

    private static class Node<T> {
        T data;
        Node<T> left, right;
        Node(T data) { this.data = data; }
    }

    public void insert(T data) {
        root = insertRecursive(root, data);
    }

    private Node<T> insertRecursive(Node<T> current, T data) {
        if (current == null) {
            return new Node<>(data);
        }
        if (data.compareTo(current.data) < 0) {
            current.left = insertRecursive(current.left, data);
        } else if (data.compareTo(current.data) > 0) {
            current.right = insertRecursive(current.right, data);
        }
        return current;
    }

    // 中序遍历验证结果
    public void inorderTraversal() {
        inorderRecursive(root);
    }

    private void inorderRecursive(Node<T> current) {
        if (current != null) {
            inorderRecursive(current.left);
            System.out.println(current.data);
            inorderRecursive(current.right);
        }
    }
}

3. 通过Scanner解析输入，创建自定义对象插入 #

从控制台读取用户输入的信息，解析成自定义对象后插入BST：

public class Main {
    public static void main(String[] args) {
        BinarySearchTree<Person> personBST = new BinarySearchTree<>();
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入3个人的信息（格式：姓名 年龄）：");
        for (int i = 0; i < 3; i++) {
            String name = scanner.next();
            int age = scanner.nextInt();
            Person person = new Person(name, age);
            personBST.insert(person);
        }

        System.out.println("BST中序遍历结果（按年龄排序）：");
        personBST.inorderTraversal();
        scanner.close();
    }
}

内容的提问来源于stack exchange，提问作者OuiOuii