从 if 和 else 递归调用相同的方法。得到意外的输出答案

【问题标题】：Calling same method recursively from if and else.Getting unexpected output从 if 和 else 递归调用相同的方法。得到意外的输出
【发布时间】：2016-05-12 09:48:35
【问题描述】：

从 if 和 else.Calee 递归调用相同的方法得到意外的输出（从 sysout 可以看到）。预期输出：4

调试代码并查看发生了什么。但不能理解太多。请帮忙

public class GetSquares {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String rectDimension="5X3";
        int noOfSquares=0;
        int noOfSq=getNoofSquares(rectDimension,noOfSquares);
        System.out.println(noOfSq);
    }

    public static  int getNoofSquares(String rectDimension,int noOfSquares){

        int length=Integer.parseInt(rectDimension.split("X")[0]);
        int breadth=Integer.parseInt(rectDimension.split("X")[1]);


        if(length<breadth){
            rectDimension=String.valueOf(breadth-length)+"X"+length;
            ++noOfSquares;
            getNoofSquares(rectDimension,  noOfSquares);
        }else if(length>breadth){
            rectDimension=String.valueOf(length-breadth)+"X"+breadth;
            ++noOfSquares;
            getNoofSquares(rectDimension,  noOfSquares);
        }else  {
            noOfSquares=noOfSquares+1;
            System.out.println(noOfSquares);
            return noOfSquares;
        }

        return noOfSquares;



    }
}

【问题讨论】：

实际输出有两行：4 和1。我不知道你在做什么，你在期待什么，你认为什么是错的。
我想返回给定矩形中可能的最大正方形数。例如：矩形 5X3。它有正方形 3*3,2*2,1*1,1*1。共4个方格。我在 getNoofSquares 方法的 else 语句中得到了输出（有一个打印 4 的 sysout）。但是当我使用 calee 方法时，我得到 1 作为输出而不是 4

标签： java recursion methods

【解决方案1】：

你没有在递归调用中持有方法getNoofSquare()的返回值，得到类似的值

noOfSquares= getNoofSquares(rectDimension,  noOfSquares);

【讨论】：

我不想保留输出。我只想将 noOfSquares 加一并调用相同的方法
静态方法中的参数在每次调用方法时都会被初始化。所以如果你想增加 noOfSquares 变量.. 然后让它成为类成员。通过将其声明为静态的。

【解决方案2】：

您的问题是 Java 中的原始类型是按值传递的，而不是按引用传递的。

public static void increment(int x) {
    x++;
}

public static void main(String... a) {
    int x = 0;
    increment(x);
    System.out.println(x);
}

此代码将打印0。

如果你想要一个“输出参数”，它必须是可变的，但int 不是。您必须创建一个作为整数持有者的类：

public class MutableInteger {

    private int value = 0;

    public void increment() {
        value++;
    }

    public int getValue() {
        return value;
    }

}

那么您的代码将如下所示：

// SOLUTION 1
public class GetSquares {

    public static void main(String[] args) {
        String rectDimension = "5X3";
        MutableInteger noOfSq = new MutableInteger();
        getNoofSquares(rectDimension, noOfSq);
        System.out.println(noOfSq.getValue());
    }

    public static void getNoofSquares(String rectDimension, MutableInteger noOfSquares) {

        int length = Integer.parseInt(rectDimension.split("X")[0]);
        int breadth = Integer.parseInt(rectDimension.split("X")[1]);

        noOfSquares.increment();

        if (length < breadth) {
            rectDimension = String.valueOf(breadth - length) + "X" + length;
            getNoofSquares(rectDimension, noOfSquares);
        } else if (length > breadth) {
            rectDimension = String.valueOf(length - breadth) + "X" + breadth;
            getNoofSquares(rectDimension, noOfSquares);
        }
    }

}

另一种方法是只使用返回值来返回结果：

// SOLUTION 2
public class GetSquares {

    public static void main(String[] args) {
        String rectDimension = "5X3";
        int noOfSq = getNoofSquares(rectDimension);
        System.out.println(noOfSq);
    }

    public static int getNoofSquares(String rectDimension) {
        int length = Integer.parseInt(rectDimension.split("X")[0]);
        int breadth = Integer.parseInt(rectDimension.split("X")[1]);

        if (length < breadth) {
            rectDimension = String.valueOf(breadth - length) + "X" + length;
            return 1 + getNoofSquares(rectDimension);
        } else if (length > breadth) {
            rectDimension = String.valueOf(length - breadth) + "X" + breadth;
            return 1 + getNoofSquares(rectDimension);
        } else {
            return 1;
        }
    }

}

另外，我建议不要进行字符串解析/拆分/构建，而是只为长度和宽度设置两个 int 参数：

// SOLUTION 2 (cleaned)
public class GetSquares {

    public static void main(String[] args) {
        String rectDimension = "5X3";

        int length = Integer.parseInt(rectDimension.split("X")[0]);
        int breadth = Integer.parseInt(rectDimension.split("X")[1]);

        int noOfSq = getNoofSquares(length, breadth);
        System.out.println(noOfSq);
    }

    public static int getNoofSquares(int length, int breadth) {
        if (length < breadth) {
            return 1 + getNoofSquares(breadth - length, length);
        } else if (length > breadth) {
            return 1 + getNoofSquares(length - breadth, breadth);
        } else {
            return 1;
        }
    }

}

【讨论】：

【解决方案3】：

Java 是按值传递的。您正在递增一个局部变量，并且您没有对递归返回的值做任何事情。

既然你之后什么都不做，但返回你也可以做得很好：

public class GetSquares {

    public static void main(String[] args) {
        String rectDimension = args.length > 0 ? args[0] : "5X3";
        System.out.println("Number of squares from " + rectDimension 
            + " is " + getNoofSquares(rectDimension));
    }

    public static  int getNoofSquares(String rectDimension){
        String parts[] = rectDimension.split("X");
        int length=Integer.parseInt(parts[0]);
        int breadth=Integer.parseInt(parts[1]);
        return getNoofSquares(length, breadth, 0);
    }

    public static  int getNoofSquares(int length, int breadth, int noOfSquares){
        if (length < breadth) {
            return getNoofSquares(breadth-length, length, noOfSquares+1);
        } else if (length > breadth) {
            return getNoofSquares(length-breadth, breadth, noOfSquares+1);
        } else {
            return noOfSquares+1;
        }
    }
}

我保留了你的累加器，所以现在它是尾递归的。 Java 还没有 TCO。

【讨论】：