Java递归构建二叉树报错：'.class expected'，求解决方法

首先明确说：这个错误和Promise完全没有关系！Promise是JavaScript里用于异步编程的概念，Java语言本身根本没有这个特性，所以别往这方面想啦～

为什么会报'.class expected'？ #

你标注的两行代码犯了两个基础的Java语法错误：

TreeNode left = new buildTree(int[] leftpre, int[] leftin); // 错误行
TreeNode right = new buildTree(int[] rightpre, int[] rightin); // 错误行

1. new关键字是用来创建类的实例对象的，而buildTree是你定义的静态方法，调用静态方法不需要用new。
2. 调用方法传递参数时，不需要指定参数的类型（比如int[]），直接传变量名即可。

Java编译器看到你在new后面写了方法名，还带了参数类型，误以为你要创建某个类的实例，但找不到对应的buildTree.class文件，所以抛出了'.class expected'的错误。

如何修复？ #

把这两行错误的调用改成正确的静态方法调用就行：

TreeNode left = buildTree(leftpre, leftin);
TreeNode right = buildTree(rightpre, rightin);

除此之外，你的代码还有几个其他问题需要修复才能正常运行：

1. 缺少TreeNode类的定义，得补充这个类；
2. 没有处理preorder为空的边界情况，会导致数组越界；
3. 主方法里的测试代码可以优化，直接调用buildTree方法验证结果。

完整修正后的代码 #

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public class Main {
    public static void main(String args[]) {
        int[] preorder = new int[] {3, 9, 8, 12, 13};
        int[] inorder = new int[] {9, 3, 12, 8, 13};
        
        TreeNode root = buildTree(preorder, inorder);
        // 测试输出左子节点值，验证是否正确构建
        System.out.println(root.left.val); // 输出9
    }

    public static TreeNode buildTree(int[] preorder, int[] inorder) {
        // 处理边界情况：空数组直接返回null
        if (preorder.length == 0 || inorder.length == 0) {
            return null;
        }
        
        TreeNode root = new TreeNode(preorder[0]);
        if (preorder.length == 1) {
            return root;
        }

        int rootindex = -1;
        for (int i = 0; i < inorder.length; i++) {
            if (inorder[i] == preorder[0]) {
                rootindex = i;
                break; // 找到后直接跳出循环，提高效率
            }
        }

        int[] leftpre = new int[rootindex];
        for (int i = 0; i < rootindex; i++) {
            leftpre[i] = preorder[i + 1];
        }

        int rightPreLength = preorder.length - (1 + rootindex);
        int[] rightpre = new int[rightPreLength];
        for (int i = 0; i < rightPreLength; i++) {
            rightpre[i] = preorder[i + 1 + rootindex];
        }

        int[] leftin = new int[rootindex];
        for (int i = 0; i < rootindex; i++) {
            leftin[i] = inorder[i];
        }

        int rightInLength = inorder.length - (1 + rootindex);
        int[] rightin = new int[rightInLength];
        for (int i = 0; i < rightInLength; i++) {
            rightin[i] = inorder[i + 1 + rootindex];
        }

        TreeNode left = buildTree(leftpre, leftin);
        root.left = left;
        TreeNode right = buildTree(rightpre, rightin);
        root.right = right;

        return root;
    }
}

额外优化建议 #

• 可以把数组拷贝的逻辑用Arrays.copyOfRange简化，减少手动循环的代码，比如int[] leftpre = Arrays.copyOfRange(preorder, 1, rootindex + 1);，这样代码更简洁。
• 可以用哈希表提前存储中序遍历的元素和索引，避免每次递归都循环查找根节点索引，提高时间效率。

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