如何加速用Java编写的递归方法 这是一个来自LeEcDebug的问题，我用C++解决了它，但是当我使用java的同一种方法时，它返回了一个超过了错误的时限。有人知道原因吗

问题是：

将排序数组转换为二叉搜索树。给定元素按升序排序的数组，将其转换为高度平衡的BST。

下面是我用Java编写的解决方案：

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode sortedArrayToBST(int[] num) {
        if(num.length == 0) {
            return null;
        } else {
            return sub(num, 0, num.length-1);
        }
    }

    public TreeNode sub(int[] num, int start, int end) {
        int indexRoot = (start+end+1) / 2;
        TreeNode root = new TreeNode(num[indexRoot]);

        if(indexRoot > start) {
            root.left = sub(num, 0, indexRoot-1);
        }
        if(indexRoot < end) {
            root.right = sub(num, indexRoot+1, end);
        }

        return root;
    }
}

/**
*二叉树的定义
*公共级树节点{
*int-val；
*左树突；
*特雷诺德右翼；
*树节点（intx）{val=x；}
* }
*/
公共类解决方案{
公共TreeNode Sorterraytobst（int[]num）{
如果（num.length==0）{
返回null；
}否则{
返回sub（num，0，num.length-1）；
}
}
公共树节点子节点（int[]num，int start，int end）{
int indexRoot=（开始+结束+1）/2；
树节点根=新树节点（num[indexRoot]）；
如果（索引根>开始）{
root.left=sub（num，0，indexRoot-1）；
}
if（indexRoot

---

有什么办法可以加快速度吗？谢谢。

组织自己的堆栈-索引对。使用堆栈放置对，并对最上面的一个调用sub（），而不是重新调用该过程

while (stack of pairs processing is not finished) {
  //get next pair and process the pair
  sub(next pair);
}

public TreeNode sub(int[] num, int start, int end) {
    int indexRoot = (start+end+1) / 2;
    TreeNode root = new TreeNode(num[indexRoot]);

    if(indexRoot > start) {
        root.left = addToStack(num, 0, indexRoot-1);
    }
    if(indexRoot < end) {
        root.right = addToStack(num, indexRoot+1, end);
    }

    return root;
}

while（对堆栈处理未完成）{
//获取下一对并处理该对
sub（下一对）；
}
公共树节点子节点（int[]num，int start，int end）{
int indexRoot=（开始+结束+1）/2；
树节点根=新树节点（num[indexRoot]）；
如果（索引根>开始）{
root.left=addToStack（num，0，indexRoot-1）；
}
if（indexRoot

代码中只有一个输入错误。正确的答案如下

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode sortedArrayToBST(int[] num) {
        if(num.length == 0) {
            return null;
        } else {
            return sub(num, 0, num.length-1);
        }
    }

    public TreeNode sub(int[] num, int start, int end) {
        int indexRoot = (start+end+1) / 2;
        TreeNode root = new TreeNode(num[indexRoot]);

        if(indexRoot > start) {
            root.left = sub(num, start, indexRoot-1);
        }
        if(indexRoot < end) {
            root.right = sub(num, indexRoot+1, end);
        }

        return root;
    }
}

/**
*二叉树的定义
*公共级树节点{
*int-val；
*左树突；
*特雷诺德右翼；
*树节点（intx）{val=x；}
* }
*/
公共类解决方案{
公共TreeNode Sorterraytobst（int[]num）{
如果（num.length==0）{
返回null；
}否则{
返回sub（num，0，num.length-1）；
}
}
公共树节点子节点（int[]num，int start，int end）{
int indexRoot=（开始+结束+1）/2；
树节点根=新树节点（num[indexRoot]）；
如果（索引根>开始）{
root.left=sub（num，start，indexRoot-1）；
}
if（indexRoot

正在使用的数组的大小是多少？Shoouldn不

root.left=sub（num，0，indexRoot-1）be
root.left=sub（num，start，indexRoot-1）？是的@cactus1是对的。您发布的代码无限递归。（这可能就是为什么会出现超时错误）哎呀！我没发现，有很多人！