Java 如何使用递归计算树中的子节点数

我设计了一个递归算法来查找字符串中的子元素数。字符串实际上是一个数组，如[1,0,1,0,1]。此字符串有三个可能的子项，[0,0,1,0,1]、[1,0,0,1]和[1,0,1,0,0]。因此，创建子项的标准是只减少字符串中的一个非零项。因为[1,0,1,0,1]中有三个非零项，所以有三个可能的子项。继续以这种方式，每个孩子现在可以有两个可能的孩子，以此类推。当字符串中只有一个非零项时，递归停止

这是我的代码：

public class Recursion {

/**
 * @param args the command line arguments
 */
    public static void main(String[] args) {
        // TODO code application logic here
        int[] c={1,0,1,0,1};
        System.out.println(num(c)); 
    }

    private static int num(int[] v){
        if(numChildren(v)==1){ 
            return 1;
        }    
        else{
            int[][] ge=children(v);
            for(int[] e:ge){
            return 1+num(e);
            }
            System.out.print("this return should never execute");
            return 0;
        }
    }

    private static int numChildren(int[] val){
        int sum=0;
        for(int i=0;i<val.length;i++){
            if(val[i]!=0){
                sum+=1;
            }   
        }
        return sum;
    }

    private static int[][] children(int[] p){
        int pChildern=numChildren(p);
        int[] d=new int[pChildern];
        int[][] r=new int[pChildern][];
        int c=0;
        for(int j=0;j<p.length;j++){
            if(p[j]!=0){
                d[c]=j;
                c++;
            }    
        }

        for(int i=0;i<pChildern;i++){
            p[d[i]]--;
            r[i]=p.clone();
            p[d[i]]++;
        }
        return r;
    }
}

公共类递归{
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）{
//此处的TODO代码应用程序逻辑
int[]c={1,0,1,0,1}；
系统输出println（num（c））；
}
私有静态int num（int[]v）{
如果（numChildren（v）==1）{
返回1；
}    
否则{
int[]ge=儿童（v）；
for（int[]e:ge）{
返回1+num（e）；
}
System.out.print（“此返回不应执行”）；
返回0；
}
}
私有静态int numChildren（int[]val）{
整数和=0；
对于（int i=0；i我并没有真正深入讨论细节，但这个块看起来很奇怪：

int[][] ge=children(v);
for(int[] e:ge){
    return 1+num(e);
}
System.out.print("this return should never execute");
return 0;

你想在这里总结所有的孩子，但你回来得太早了。应该是这样的：

int[][] ge=children(v);
int totChild = 0;
for(int[] e:ge){
    totChild = totChild + num(e);
}

return totChild;

我认为下面的代码可能非常适合您的需要

{1,0,1,0,1}-->给出7（2x2x2-1）

{1,1,1,1,1}-->给出31（2x2x2x2x2x2-1）

{4,4,1,1,1}-->给出199（5x5x2x2x2-1）

-1是从子级中删除{0,0,0,0,0}

public class Recursion {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int[] c={4,4,1,1,1};
        System.out.println(num(c, 0)); 
    }

    private static void print(int[] v) {
        System.out.print("[");
        for ( int i = 0; i < v.length; ++i ) {
            System.out.print(v[i] + ",");
        }
        System.out.println("] ");
    }

    private static int num(int[] v, int k){
        if(numChildren(v)==1){ 
            return 1;
        }
        else{
            int r = 1;
            for ( int i = k; i < v.length; ++i ) {
                if ( v[i] > 0) {
                    int o = v[i];
                    v[i] = o - 1;
                    print(v);
                    r += num(v, i);
                    v[i] = o;
                }
            }
            return r;
        }
    }

    private static int numChildren(int[] val){
        int sum=0;
        for(int i=0;i<val.length;i++){
            if(val[i]!=0){
                sum+=1;
            }   
        }
        return sum;
    }
}

公共类递归{
/**
*@param指定命令行参数
*/
公共静态void main（字符串[]args）{
//此处的TODO代码应用程序逻辑
int[]c={4,4,1,1,1}；
系统输出println（num（c，0））；
}
专用静态无效打印（int[]v）{
系统输出打印（“[”）；
对于（int i=0；i0）{
int o=v[i]；
v[i]=o-1；
印刷品（五）；
r+=num（v，i）；
v[i]=o；
}
}
返回r；
}
}
私有静态int numChildren（int[]val）{
整数和=0；
对于（int i=0；iYou are write），我犯了这个错误。但是，即使在更正后，结果仍然无效。例如[4,4,1,1,1]的可能子级数是200。但代码生成69300，这是错误的。我没有包含左右子项的平衡树。如果您使用getter而不是字段
子项
，我会很高兴。
public class Recursion {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        int[] c={4,4,1,1,1};
        System.out.println(num(c, 0)); 
    }

    private static void print(int[] v) {
        System.out.print("[");
        for ( int i = 0; i < v.length; ++i ) {
            System.out.print(v[i] + ",");
        }
        System.out.println("] ");
    }

    private static int num(int[] v, int k){
        if(numChildren(v)==1){ 
            return 1;
        }
        else{
            int r = 1;
            for ( int i = k; i < v.length; ++i ) {
                if ( v[i] > 0) {
                    int o = v[i];
                    v[i] = o - 1;
                    print(v);
                    r += num(v, i);
                    v[i] = o;
                }
            }
            return r;
        }
    }

    private static int numChildren(int[] val){
        int sum=0;
        for(int i=0;i<val.length;i++){
            if(val[i]!=0){
                sum+=1;
            }   
        }
        return sum;
    }
}