Java StackOverflow错误，有人能告诉我为什么我的代码会生成它吗？

我试图编写一个递归函数，告诉我一棵树是否是另一棵树的子树，但它给了我一个stackoverflow错误。我目视检查了代码，但没有看到任何错误！因此，我在这里向我的命运屈服。谢谢你的帮助

附言：二元树烯醇只是一种普通的树烯醇 BinaryTwinNode只是一个包含两个BinaryTreeNode的类。 我正在使用EclipseJava

以下是我用来针对这些方法运行的代码：

    BinarySearchTree healthyTree = new BinarySearchTree();
    BinaryTreeNode no1 = new BinaryTreeNode(1);
    BinaryTreeNode no2 = new BinaryTreeNode(2);
    BinaryTreeNode no3 = new BinaryTreeNode(3);
    BinaryTreeNode no4 = new BinaryTreeNode(4);
    BinaryTreeNode no5 = new BinaryTreeNode(5);

    healthyTree.insert(no1);
    healthyTree.insert(no2);
    healthyTree.insert(no3);
    healthyTree.insert(no4);
    healthyTree.insert(no5);

    BinarySearchTree betterTree = new BinarySearchTree();
    betterTree.insert(no3);
    betterTree.insert(no1);
    betterTree.insert(no2);
    betterTree.insert(no4);
    betterTree.insert(no5);

   boolean tru = betterTree.isSubtree(healthyTree.root, (new BinarySearchTree(no5)).root);

以下是错误消息：

 java.lang.StackOverflowError
at java.util.LinkedList.addFirst(LinkedList.java:293)
at algorithim.BinarySearchTree.matchingTrees(BinarySearchTree.java:811)
at algorithim.BinarySearchTree.isSubtree(BinarySearchTree.java:784)
at algorithim.BinarySearchTree.isSubtree(BinarySearchTree.java:789)
at algorithim.BinarySearchTree.isSubtree(BinarySearchTree.java:788)
at algorithim.BinarySearchTree.isSubtree(BinarySearchTree.java:789)
at algorithim.BinarySearchTree.isSubtree(BinarySearchTree.java:789)
at algorithim.BinarySearchTree.isSubtree(BinarySearchTree.java:788)
at algorithim.BinarySearchTree.isSubtree(BinarySearchTree.java:789)
at algorithim.BinarySearchTree.isSubtree(BinarySearchTree.java:789)
at algorithim.BinarySearchTree.isSubtree(BinarySearchTree.java:788)
......

isSubtree，matchingTrees方法详细信息：

public boolean isSubtree(BinaryTreeNode originNode, BinaryTreeNode opposeNode){
    if(opposeNode == null)
        return true;

    if(originNode == null)
        return false;

    //System.out.println("its a match? "+matchingTrees(originNode, opposeNode));
    //perform work


    if(matchingTrees(originNode, opposeNode)){
        return true;
    }else{

        return isSubtree(originNode.left, opposeNode)||
        isSubtree(originNode.right, opposeNode);
    }


 }

 /**
  * return true if origin matches the differ
  * @param origin
  * @param differ
  * @return
  */
 public boolean matchingTrees(BinaryTreeNode origin, BinaryTreeNode differ){

     if(origin == null)
         return false;
     if(differ == null)
         return true;


     LinkedList<BinaryTwinNode> queue = new LinkedList<BinaryTwinNode>();
     queue.addFirst(new BinaryTwinNode(origin, differ));
     BinaryTwinNode temp;

     while(queue.isEmpty() == false){    
        temp = queue.removeLast();

        if(temp.origin.value != temp.oppose.value){
            return false;
        }

        if(temp.origin.left != null && temp.oppose.left != null){
            queue.addFirst(new BinaryTwinNode(temp.origin.left, temp.oppose.left));

        }else if(temp.origin.left == null && temp.oppose.left != null){
            return false;
        }else if(temp.origin.left != null && temp.oppose.left == null){
            return false;
        }

        if(temp.origin.right != null && temp.oppose.right != null){
            queue.addFirst(new BinaryTwinNode(temp.origin.right, temp.oppose.right));

        }else if(temp.origin.right == null && temp.oppose.right != null){
            return false;
        }else if(temp.origin.right != null && temp.oppose.right == null){
            return false;
        }
     }
     //default
     return true;
 }

public boolean isSubtree（二进制树节点originNode，二进制树节点对立面）{
if（oppositenode==null）
返回true；
if（originNode==null）
返回false；
//System.out.println（“这是一个匹配？”+matchingTrees（originNode，oppositenode））；
//工作
if（匹配树（原始节点，反向节点））{
返回true；
}否则{
返回isSubtree（originNode.left，反向节点）||
isSubtree（originNode.right，对立节点）；
}
}
/**
*如果原点与差异匹配，则返回true
*@param-origin
*@param不同
*@返回
*/
公共布尔匹配树（二进制树节点原点，二进制树节点不同）{
如果（原点==null）
返回false；
if（difference==null）
返回true；
LinkedList队列=新建LinkedList（）；
addFirst（新的二进制TwinNode（origin，different））；
二元双节点温度；
while（queue.isEmpty（）==false）{
temp=queue.removeLast（）；
if（温度原点值！=温度原点值）{
返回false；
}
if（temp.origin.left！=null&&temp.origin.left！=null）{
addFirst（新的BinaryTwinNode（temp.origin.left，temp.revolve.left））；
}else if（temp.origin.left==null&&temp.reverse.left！=null）{
返回false；
}else if（temp.origin.left！=null&&temp.reverse.left==null）{
返回false；
}
if（temp.origin.right！=null&&temp.origin.right！=null）{
addFirst（新的BinaryTwinNode（temp.origin.right，temp.revolute.right））；
}else if（temp.origin.right==null&&temp.reverse.right！=null）{
返回false；
}else if（temp.origin.right！=null&&temp.reverse.right==null）{
返回false；
}
}
//违约
返回true；
}

请发布您收到的错误。可能是无限循环，请检查基本情况。令人惊讶的是，当我切换到按级别顺序执行此操作时，不会出现stackoverflow错误。我希望有人能告诉我，当我递归地这样做时，为什么它会给我一个错误（我可以想到两种可能性：（1）你确定你的

原始节点

真的是一棵树吗？如果给定的任何节点在一个循环中连接，你的程序总是抛出StackOverflower错误。（2）如果它真的是一棵树，那么对于您分配的堆栈量来说，树可能太深了。请尝试分配更多的堆栈空间。（例如，

java-Xss…

）关于StackOverflow的一个StackOverflow问题…对我来说太复杂了。请发布你得到的错误。可能是无限循环，检查你的基本情况。令人惊讶的是，当我切换到按级别顺序执行此操作时，它不会给我StackOverflow错误。我希望有人能启发我，为什么我递归执行此操作时它会给我错误y、 ：（我可以想到两种可能性：（1）你确定你的

原始节点

真的是一棵树吗？如果给定的任何节点在一个循环中连接，你的程序将始终抛出StackOverflower错误。（2）如果它真的是一棵树，那么可能这棵树对于您分配的堆栈量来说太深了。尝试分配更多的堆栈空间。（例如，

java-Xss…

）关于StackOverflow的StackOverflow问题……对我来说太复杂了