我正在尝试构建一个树,每个节点有六个子节点。我为生成树而编写的方法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>
答案 0 :(得分:5)
找到你的问题:
pdepth = parent.depth++;
应该是:
pdepth = parent.depth + 1;
您是后递增,这意味着先执行赋值,然后再执行增量。 pdepth的值始终为零。
答案 1 :(得分:0)
罪魁祸首是
pdepth = parent.depth ++;
线。
您正在使用后增量运算符而不是预增量运算符。这样 parent.depth 总是 0 ,从而导致无限递归。
-JB -