Java 递归算法中的奇怪行为，

作为编程101课程的一部分，我正在用Java编写一个递归算法来计算斐波那契数。代码如下：

public class Fib {

    public static void main(String[] args) {
        Fib fib = new Fib();
    }

    public Fib() {
        int end = 9;
        long[] nums = new long[2];
        printFib(0, end, nums);
    }

    private void printFib(int i, int end, long[] nums) {
        while(i < end) {
            if(i == 0 || i == 1) {
                nums[i] = 1;
                System.out.println("1");
            } else {
                long fib;
                fib = 0;
                fib += (nums[0] + nums[1]);
                nums[0] = nums[1];
                nums[1] = fib;
                System.out.println(fib);    
            }
            i++;
            printFib(i, end, nums);
        }
    }
}

公共类Fib{
公共静态void main（字符串[]args）{
Fib=新的Fib（）；
}
公共Fib（）{
int-end=9；
long[]nums=新长[2]；
printFib（0，结束，nums）；
}
私有void printFib（int i，int end，long[]nums）{
while（i

当我单步执行程序时，它按预期工作，直到

I

等于

end

，变量告诉

printFib

方法它应该打印多少个斐波那契数。当

ì

等于

end

时，（i<1）

按预期返回false，程序转到最后一个

}

时，现在您（我） 期望程序返回我最初调用函数的构造函数，并且程序应该退出，而不是这种情况。程序返回while语句并以某种方式再次计算为false。然后它再次执行相同的操作，除了第二次将

i

减少1（什么？！），然后在到达if语句时进入

else

子句。然后，它反复做同样的事情，将从

i

中减去的量在1和2之间交替。我问过我的老师，他无法解释

如果我将

while

替换为

if

，那么该程序的工作方式完全符合我的预期，因此可能有一些关于

while

的内容我不知道

编辑

---

因此，我现在意识到，每次调用该方法时，都会存储不同的值，当该方法退出并且

I

=

end

时，程序会返回到以前的调用，在那里我有不同的值。

您实现了一个迭代算法来计算斐波那契级数。这就是while循环所做的。在最后进行递归调用--

printFib（i，end，nums）

没有意义

---

如果您想要递归实现，则不需要整个while循环。

您实现了一个迭代算法来计算斐波那契级数。这就是while循环所做的。在最后进行递归调用--

printFib（i，end，nums）

没有意义

---

如果您想要递归实现，则不需要整个while循环。

我觉得这段代码不太合适

我建议您不要使用您的方法打印。向main返回一个值并让它打印

递归方法中不应该有while循环。这就是迭代——这正是您在这里试图避免的

您的方法应该具有停止条件和对自身的调用。那不是你在做的

这样想：

/**
 * Recursive Fibonnaci
 * User: mduffy
 * Date: 2/11/2015
 * Time: 8:50 AM
 * @link http://stackoverflow.com/questions/28455798/strange-behavior-in-recursive-algorithm/28455863#28455863
 */
public class Math {

    private static Map<Integer, Integer> memo = new ConcurrentHashMap<Integer, Integer>();

    public static void main(String [] args) {
        for (String arg : args) {
            int n = Integer.valueOf(arg);
            System.out.println(String.format("n: %d fib(n): %d", n, fibonnaci(n)));
        }
    }

    public static int fibonnaci(int n) {
        if (n < 0) throw new IllegalArgumentException("index cannot be negative");
        int value = 0;
        if (memo.containsKey(n)) {
            value = memo.get(n);
        } else {
            if (n <= 1) {                
                value = n;
            } else {
                value = fibonnaci(n-1)+fibonnaci(n-2);
            }
            memo.put(n, value);
        }
        return value;
    }
}

/**
*递归Fibonnaci
*用户：mduffy
*日期：2015年11月2日
*时间：上午8:50
*@linkhttp://stackoverflow.com/questions/28455798/strange-behavior-in-recursive-algorithm/28455863#28455863
*/
公共课数学{
私有静态映射备忘录=新的ConcurrentHashMap（）；
公共静态void main（字符串[]args）{
for（字符串arg:args）{
int n=整数。valueOf（arg）；
System.out.println（String.format（“n:%d fib（n）：%d”，n，fibonnaci（n））；
}
}
公共静态int fibonnaci（int n）{
如果（n<0）抛出新的IllegalArgumentException（“索引不能为负”）；
int值=0；
如果（备忘录容器（n））{
值=memo.get（n）；
}否则{
如果（n我觉得这个代码不对

我建议您不要从方法中打印。将一个值返回到main并让它打印

您的递归方法中不应该有while循环。这就是迭代——这正是您在这里试图避免的

你的方法应该有一个停止条件和对自身的调用。这不是你要做的

这样想：

/**
 * Recursive Fibonnaci
 * User: mduffy
 * Date: 2/11/2015
 * Time: 8:50 AM
 * @link http://stackoverflow.com/questions/28455798/strange-behavior-in-recursive-algorithm/28455863#28455863
 */
public class Math {

    private static Map<Integer, Integer> memo = new ConcurrentHashMap<Integer, Integer>();

    public static void main(String [] args) {
        for (String arg : args) {
            int n = Integer.valueOf(arg);
            System.out.println(String.format("n: %d fib(n): %d", n, fibonnaci(n)));
        }
    }

    public static int fibonnaci(int n) {
        if (n < 0) throw new IllegalArgumentException("index cannot be negative");
        int value = 0;
        if (memo.containsKey(n)) {
            value = memo.get(n);
        } else {
            if (n <= 1) {                
                value = n;
            } else {
                value = fibonnaci(n-1)+fibonnaci(n-2);
            }
            memo.put(n, value);
        }
        return value;
    }
}

/**
*递归Fibonnaci
*用户：mduffy
*日期：2015年11月2日
*时间：上午8:50
*@linkhttp://stackoverflow.com/questions/28455798/strange-behavior-in-recursive-algorithm/28455863#28455863
*/
公共课数学{
私有静态映射备忘录=新的ConcurrentHashMap（）；
公共静态void main（字符串[]args）{
for（字符串arg:args）{
int n=整数。valueOf（arg）；
System.out.println（String.format（“n:%d fib（n）：%d”，n，fibonnaci（n））；
}
}
公共静态int fibonnaci（int n）{
如果（n<0）抛出新的IllegalArgumentException（“索引不能为负”）；
int值=0；
如果（备忘录容器（n））{
值=memo.get（n）；
}否则{
如果（n基本上发生了这种情况，因为我猜您认为i是一个引用，它将影响调用子fibuncai方法的fibuncai方法的基本调用。这将最终导致许多调用fibuncai方法

在我看来，循环在你递归求解它的方式中没有意义。
基本上，这是因为我猜你认为i是一个引用，它将影响调用子fibuncai方法的fibuncai方法的基本调用。这将最终导致许多调用fibuncai方法

在我看来，循环在你的递归解决方法中没有意义。
明白。但是如果我用if-st替换while循环