例子问题
例子问题1:递归
考虑下面的代码:
public static void main(String[] args) {
System.out.println(方程(8));
}
公共静态int方程(int a) {
如果(a <= 5) {
返回12;
}
返回式(a-2) *式(a-1);
}
上面代码的输出是什么?
这个函数方程是递归方法,这意味着它调用自身。跟踪递归方法最简单的方法是首先注意它的停止情况。为此,它是:
如果(a <= 5) {
返回12;
}
在本例中,对于任何小于或等于5的值,它返回12。现在,开始跟踪:
式(8)=式(6)*式(7)
式(7)=式(5)*式(6)
式(6)=式(4)*式(5)
因此,式(6)为
12 * 12或144
因此,我们知道:
式(7)= 12 * 144 = 1728
式(8)= 144 * 1728 = 248832
问题51:编程结构
下面哪个是递归阶乘函数?
回想一下阶乘的一个例子是:
其他的都没有
公共长阶乘(long a) {
Long ret = 1;
For (int I = 2;I < a;我+ +){
Ret *= i;
}
返回受潮湿腐烂;
}
公共长阶乘(long a) {
A * A -1 * A -2 * A -3 * A -4;
}
公共长阶乘(long a) {
如果(a <= 1) {
返回1;
}
返回a *阶乘(a-1);
}
公共长阶乘(long a) {
返回a * factorial(a-1) * factorial(a-2);
}
公共长阶乘(long a) {
如果(a <= 1) {
返回1;
}
返回a *阶乘(a-1);
}
回想一下,递归函数调用自身。因此,仅凭它们在本质上不是递归的事实,您就可以排除几个答案。(事实上,有循环的计算是正确的。)现在,你可以这样考虑阶乘:
然后……
等等。
因此,你在1处有一个停止的情况,它等于1。对于任何其他值,您将返回一个递归值,即参数一个然后factorial方法调用witha - 1.
问题52:编程结构
考虑下面的代码:
public static void main(String[] args) {
system . out。println(foo(“这是我最喜欢的:编程太棒了!!”));
}
字符串foo(字符串s) {
如果(! s.equals (" ")) {
charat (0);
if(c >= 'A' && c <= 'Z') {
return Character.toLowerCase(c) + foo(s.substring(1));
} else if (c >= 'a' && c <= 'z'){
return Character.toUpperCase(c) + foo(s.substring(1));
}
返回foo (s.substring (1));
}
返回";
}
的输出是什么主要
以上功能?
这是我最喜欢的
这是我最喜欢的:编程太棒了!!
这是我最喜欢的
tHISISMYFAVORITEyAYFORPROGRAMMING
这是我最喜欢的:编程太棒了!!
tHISISMYFAVORITEyAYFORPROGRAMMING
的喷火
方法显然是递归的。因此,让我们看看我们的条件:
如果年代
是""
,然后代码到达基本情况(在最后):返回";
现在,对于其他字符串,嵌入了两种情况:
c> =“一个”& &c< =
“Z”
而且c> =“一个”& &c< =“z”
请注意,c
字符串的第一个字符。对于这两种情况,如果第一个字符是大写的,函数就把它变成小写的,如果它是小写的,函数就把它变成大写的。然后,它对自己进行递归调用,使用第一个字符之后的字符串剩余部分。如果这两个都没有到达,它只调用自己,忽略第一个字符。因此,这段代码将“翻转”字母字符的任何大小写,但将忽略所有其他字符。这就是为什么正确答案是压缩后的字符串:tHISISMYFAVORITEyAYFORPROGRAMMING
例子问题1:递归
下面哪一个是一个递归方法的总和的整数列表的内容?(选择最佳答案。)
public static int val(List int) {
Int ret = 0;
For (int I = 0;I < int .size();我+ +){
Ret += int .get(i);
}
返回受潮湿腐烂;
}
public static int val(List int) {
If (int .size() == 0) {
返回0;
}其他{
返回int .remove(0) + val(int);
}
}
public static int val(List int) {
If (int .size() == 0) {
返回0;
}其他{
返回int .get(0) + val(int。分表(ints.size ()));
}
}
public static int val(List int) {
返回int .get(0) + val(int。分表(ints.size ()));
}
公共int val(列表int) {
返回int .get(0) + val(int - 1);
}
public static int val(List int) {
If (int .size() == 0) {
返回0;
}其他{
返回int .get(0) + val(int。分表(ints.size ()));
}
}
回想一下,递归方法是一个调用自身的方法,慢慢地朝着它终止的“基本情况”工作。因此,您可以立即消除具有迭代循环的选项。这不是递归。
接下来,有两个方法有返回值:
返回int .get(0) + val(int。分表(ints.size ()));
返回int .get(0) + val(int - 1);
这两种方法都行不通,因为它们永远不会终止。(好吧,它们会终止,但只会报错!)另外,第二个是毫无意义的——你不能从一个列表中减去1 !
最后,考虑具有递归返回值的选项:
返回int .remove(0) + val(int);
这实际上会正确地添加项目。然而,通过从列表中删除项目,您将在添加它们的过程中破坏列表!因此,剩下的选项是这个问题的最佳选项:
public static int val(List int) {
If (int .size() == 0) {
返回0;
}其他{
返回int .get(0) + val(int。分表(ints.size ()));
}
}
例子问题221:计算机科学
公共静态int foo(int a, int b) {
If (b <= 1 || b <= a) {
返回1;
}
返回(b - a) * foo(a,b-1);
}
根据上面的代码,下面函数调用的值是什么:
foo(5、9);
36
16
24
18
32
24
这个函数喷火是递归的,意思是它调用自己。因此,您应该从寻找它的终止点开始。根据上面的定义,当b <= 1或b <= a时,它将终止。在这两种情况下,它将返回1。
现在,让我们对调用进行跟踪:
Foo (5,9) = (9-5) * Foo (5,8) = 4 * Foo (5,8)
Foo (5,8) = (8-5) * Foo (5,7) = 3 * Foo (5,7)
Foo (5,7) = (7-5) * Foo (5,6) = 2 * Foo (5,6)
Foo (5,6) = (6-5) * Foo (5,5) = 1 * Foo (5,5)
Foo (5,5) = 1
因此,仔细追溯,我们得到:
Foo (5,9) = 4 * 3 * 2 * 1 * 1 = 24
例子问题1:递归
公共静态int foo(int a) {
如果(a <= 3) {
返回1;
}
返回a * foo(a - 3) * foo(a - 4);
}
下面调用上面定义的函数的值是什么:
foo (8)
144
240
224
160
140
160
的喷火方法是递归的,因此需要首先找到停止的情况。这发生在a <= 3时。此时,该方法返回1。现在,基于这个事实,我们可以开始跟踪方法:
Foo (8) = 8 * Foo (5) * Foo (4)
Foo (5) = 5 * Foo (3) * Foo (1)
Foo (4) = 4 * Foo (1) * Foo (0)
Foo (0) = Foo (1) = Foo (3) = 1
因此,我们知道:
Foo (8) = 8 * 5 * 1 * 1 * 4 * 1 * 1 = 160
例子问题1:递归
公共无效抽取(){
反复出现(11);
}
Void重复出现(int count){
If (count == 0)
返回;
其他{
system . out。打印(count + " ");
Int重新计数=计数- 2;
反复出现(叙述);
返回;
}
}
代码打印什么?
11 9 7 5 3 1 -1
9 7 5 3 1 -1
错误,无限循环。
11 9 7 5 3 1
9 7 5 3 1
错误,无限循环。
这将创建一个无限循环,因为永远不会达到结束循环的条件。由于count永远不等于0,count会不断地被输入到repeat中,没有结束。
例子问题1:递归
公共无效抽取(){
反复出现(10);
}
Void重复出现(int count){
If (count == 0)
返回;
其他{
system . out。打印(count + " ");
Int重新计数=计数- 2;
反复出现(叙述);
返回;
}
}
代码的输出是什么?
8 6 4 2
10 8 6 4 2
10 8 6 4 2 0
8 6 4 2 0
错误,无限循环
10 8 6 4 2
数字10输入到recurs并打印count,从count减去2,然后输入到recurs。
因此,第一次迭代得到,10。
第二次迭代得到,10,8。
这样写是因为它把8放在第一次迭代的值之后。
继续这样下去,我们得到,
10 8 6 4 2。
当count达到0时,什么也不打印。
例子问题1:递归
调用run()后这个阶乘代码片段返回什么?
公共无效运行(){
Int n = 2;
N = factorial(N);
N = N +阶乘(N);
System.out.println (n);
}
公共int阶乘(int n) {
如果(n==1) {
返回1;
}
其他{
返回n *阶乘(n - 1);
}
}
4将被打印出来
6将被打印出来
3将被打印出来
2将被打印出来
4将被打印出来
4将被打印出来,因为阶乘(2)= 2。加上阶乘(2)+ 2 = 4。也可以写成2!+ 2 != 4。
N在第一次分配时是2
N被赋值给factorial(2) = 2
N被赋值为N(2) +阶乘(2)= 2所以2+2 = 4
打印出来的时候N是4
例子问题2:递归
斐波那契数列是一个经典的例子:_________
选择最好的答案。
以上都不是
选择
迭代
递归
递归
斐波那契数列在数学上被称为递归关系。在编程中,我们使用递归方法或简单地递归表示递归关系。斐波那契数列是递归的一个很好的例子。