Question

我设计了一个递归算法来查找字符串中的子项数。该字符串实际上是一个数组，如[1,0,1,0,1]。这个字符串有三个可能的子节点是[0,0,1,0,1]，[1,0,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;
    }
}

我的代码确实执行但没有产生正确的结果。它应该打印6但它打印3。

任何人都可以告诉我这段代码有什么问题吗？

Answer 1

// Returns size of subtree including the root
int getNumChilds(Node node) {
    int count = 1;
    for (Node child : node.getChildren()) {
        count += getNumChilds(child);
    }        
    return count;
}

Answer 2

我没有真正详细说明，但这个块看起来很奇怪：

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;

Answer 3

我认为以下代码可能非常适合您的需求。

{1,0,1,0,1} - ＆gt;给出7（2 x 2 x 2 - 1）

{1,1,1,1,1} - ＆gt;给出31（2 x 2 x 2 x 2 x 2 - 1）

{4,4,1,1,1} - ＆gt;给出199（5 x 5 x 2 x 2 x 2 - 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;
    }
}

如何使用递归计算树中的子项数

3 个答案: