用Java递归生成树

时间:2011-11-14 19:47:03

标签: java recursion tree stack-overflow

我正在尝试构建一个树,每个节点有六个子节点。我为生成树而编写的方法genB导致堆栈溢出。

public class TreeTest
{   

    public static void main(String Args[])
    {   
        sBNode bTree;
        sWNode wTree;

        bTree = new sBNode();
        wTree = new sWNode();

        TreeTest ai = new TreeTest();       

        bTree.depth = 0;
        System.out.println(bTree.depth);
        ai.genB(bTree, 2);
        ai.printTree(bTree);    
    }

    public Treetest()
    {

    }

    public boolean leaf(sBNode node)
    {
        if(node.pe1==null && node.pe2==null && node.pe3==null && node.ee1==null && node.ee2==null && node.ee3==null)
            return true;
        else
            return false;
    }

    public void genB(sBNode parent, int ddepth)
    {
        int pdepth;

        if(parent.depth != ddepth)
        {           
            System.out.println(parent.depth);
            pdepth = parent.depth++;
            sBNode pe1 = new sBNode();
            sBNode pe2 = new sBNode();
            sBNode pe3 = new sBNode();  
            sBNode ee1 = new sBNode();
            sBNode ee2 = new sBNode();
            sBNode ee3 = new sBNode();

            pe1.depth = pdepth;
            pe2.depth = pdepth;
            pe3.depth = pdepth;
            ee1.depth = pdepth;
            ee2.depth = pdepth;
            ee3.depth = pdepth;
            pe1.parent = parent;
            pe2.parent = parent;
            pe3.parent = parent;
            ee1.parent = parent;
            ee2.parent = parent;
            ee3.parent = parent;

            genB(pe1, ddepth);
            //genB(pe2, ddepth);
            //genB(pe3, ddepth);
            //genB(ee1, ddepth);
            //genB(ee2, ddepth);
            //genB(ee3, ddepth);            
        }       
    }

    public void printTree(sBNode node)
    {
        while(!leaf(node))
        {
            System.out.println(node.depth);
            printTree(node.pe1);
            printTree(node.pe2);
            printTree(node.pe3);
            printTree(node.ee1);
            printTree(node.ee2);
            printTree(node.ee3);
        }
    }
}

final class sBNode
{   
    public String state = "BCXXXCXXX";

    //utility value
    public boolean war;
    public int score;
    public int oscore;
    public int utility;
    public int min;
    public int max;
    public int depth;

    sBNode pe1;
    sBNode pe2;
    sBNode pe3; 
    sBNode ee1;
    sBNode ee2;
    sBNode ee3;
    sBNode parent;

    public sBNode()
    {
        war = false;
        score = 0;
        oscore = 0;
        utility = 0;
        min = 0;
        max = 0;
        depth = 0;
    }
}

这是家庭作业项目的一部分,最终目标是使用树的搜索来设计游戏,所以我真的不想要一个彻头彻尾的答案,而是暗示导致(接近)无限递归的原因。 / p>

2 个答案:

答案 0 :(得分:5)

找到你的问题:

pdepth = parent.depth++;

应该是:

pdepth = parent.depth + 1;

您是后递增,这意味着先执行赋值,然后再执行增量。 pdepth的值始终为零。

答案 1 :(得分:0)

罪魁祸首是 pdepth = parent.depth ++;
线。

您正在使用后增量运算符而不是预增量运算符。这样 parent.depth 总是 0 ,从而导致无限递归。

-JB -