0

有人可以帮我理解这个解决方案吗，我的意思是帮助我遍历所有内容，以便像我一样愚蠢的人理解它。太感谢了 ：（

         public void recurse(int n, char one, char two, char three)
         {
               if(n == 1)
               System.out.println(n + " " + one + " " + two);
               else
               { 
                   recurse(n - 1, one, three, two);
                   System.out.println(n + " " + one + " " + two);
                }
          }

函数调用：

          recurse (4, 'A', 'B', 'C');
4

5 回答 5

1

this.recurse (4, 'A', 'B', 'C');

第一轮：n 不是 ==1 -->recurse(3, 'A', 'C', 'B');

第二轮：n 不是 ==1 -->recurse(2, 'A', 'B', 'C');

第三轮：n 不是 == 1 -->recurse(1, 'A', 'C', 'B');

第四轮：n ==1 --> 控制台打印：“1 A C”

回到递归链：

控制台打印：“2 A B”

控制台打印：“3 A C”

控制台打印：“4 A B”

控制台中的最终输出将是

1 A C
2 A B
3 A C
4 A B
于 2013-11-01T06:23:37.870 回答
1

每次从该行递归调用该方法时它都会切换 - 它递归调用多少次？请记住，每次调用该方法时，参数都不同于任何其他调用。– 用户201535

这位用户对我说得很清楚，再次感谢您。

于 2013-11-01T06:23:55.387 回答
1

从另一个函数调用一个函数的想法立即暗示了一个函数调用自身的可能性。Java 中的函数调用机制支持这种可能性，称为递归。递归是一种强大的通用编程技术，是许多至关重要的计算应用程序的关键，从为信息处理提供基本支持的组合搜索和排序方法（第 4 章）到用于信号处理的快速傅立叶变换（第9）。

你的第一个递归程序。递归的HelloWorld是实现阶乘函数，对正整数N的定义由等式

N! = N × (N-1) × (N-2) × ... × 2 × 1

N！使用 for 循环很容易计算，但 Factorial.java 中更简单的方法是使用以下递归函数：

public static int factorial(int N) { 
   if (N == 1) return 1; 
   return N * factorial(N-1); 
}

您可以通过注意到 factorial() 返回 1 = 1 来说服自己它会产生所需的结果！当 N 为 1 并且如果它正确计算值

(N-1)! = (N-1) × (N-2) × ... × 2 × 1

然后它正确计算值

N! = N × (N-1)! = N × (N-1) × (N-2) × ... × 2 × 1

我们可以像跟踪任何函数调用序列一样跟踪这个计算。

factorial(5) 
   factorial(4) 
      factorial(3) 
         factorial(2) 
            factorial(1) 
               return 1 
            return 2*1 = 2 
         return 3*2 = 6 
      return 4*6 = 24 
   return 5*24 = 120

我们的 factorial() 实现展示了每个递归函数所需的两个主要组件。

The base case returns a value without making any subsequent recursive calls. It does this for one or more special input values for which the function can be evaluated without recursion. For factorial(), the base case is N = 1.

The reduction step is the central part of a recursive function. It relates the function at one (or more) inputs to the function evaluated at one (or more) other inputs. Furthermore, the sequence of parameter values must converge to the base case. For factorial(), the reduction step is N * factorial(N-1) and N decreases by one for each call, so the sequence of parameter values converges to the base case of N = 1. 


Now in your case (n==1) is the base condition or terminating condition.
recurse(4,'A','B','C')
  recurse(3,'A','C','B')
     recurse(2,'A','B','C')
        recurse(1,'A','C','B')

        return : 1 A C
     return : 2 A B
   return : 3 A C
return : 4 A B

final output : 
1 A C
2 A B
3 A C
4 A B
于 2013-11-01T06:47:22.870 回答
0

首先，它会走到最后一行，recurse (4, 'A', 'B', 'C'); 这是一个名为'recurse'的函数调用，它传入的参数，对应于（int n，char一，char二，char三）；

现在当函数被调用并传入参数时，它检查 (n == 1) 的值，如果这个条件成立，它通过这个语句写入 'n', 'one', 'two' 的值系统.out.println(n + " " + 一 + " " + 二);

然后如果这个 (n == 1) 条件无效，它会跳转到 else { recurse(n - 1, one, 三, 二); System.out.println(n + " " + 一 + " " + 二); 现在这里是递归发生的地方，意味着一个函数“递归”在它自己的身体里一次又一次地调用自己。

现在当它进入 else 的主体时 - 它会，所以它会调用 recurse(n - 1, one, three, two); 并且函数 recurse 将再次执行，这将发生直到 n = 1，即 - 在第 4 次迭代中。功能完成。

于 2013-11-01T06:28:27.373 回答
0

首先你需要了解什么是递归。

递归意味着一个方法一次又一次地调用自己，所以现在你会想知道这个函数总是会调用自己，那么它什么时候会停止呢？基本条件来了

即在您的代码中是 if (n == 1)

当 n==1 时，函数将停止调用自身并打印结果。

你用值4调用函数

所以第一次调用将是递归的（4，'A'，'B'，'C'）；

它将进入函数并查看 n==1 是否在第一次迭代中为4。

它将再次使用n-1调用该函数，该函数将为3

它将继续这样调用函数，直到 n 等于 1。

然后它将打印1 AB

希望你现在得到它。

于 2013-11-01T06:24:38.843 回答