循环一定可以改成递归吗？

有这样的循环语句，想改成递归的形式。
for(int x=0;x<10;x++)
{
 for(int y=0;y<10;y++)
 {
  for(int z=0;z<10;z++)
  {
   System.out.println(""+x+y+z);
  }
 }
}

31 个解决方案

#1

循环和递归是解决不同层面问题的。
同级的遍历就是循环了。如循环一个班中的说有学生。
而有层次的则需要递归了，如树形结构的结构。

你上面的例子中只有3个层次，还可以用循环，但如果你事前不知道到底有多少个层级，
那么就必须用到递归了。

#2

引用 1 楼 mayuanfei 的回复:

循环和递归是解决不同层面问题的。 
同级的遍历就是循环了。如循环一个班中的说有学生。 
而有层次的则需要递归了，如树形结构的结构。 

你上面的例子中只有3个层次，还可以用循环，但如果你事前不知道到底有多少个层级， 
那么就必须用到递归了。

学习了  能不能把这个改成递归的程序写出来  学习一下

#3

引用 1 楼 mayuanfei 的回复:

循环和递归是解决不同层面问题的。 
同级的遍历就是循环了。如循环一个班中的说有学生。 
而有层次的则需要递归了，如树形结构的结构。 

你上面的例子中只有3个层次，还可以用循环，但如果你事前不知道到底有多少个层级， 
那么就必须用到递归了。

大哥，我只是举个例子，我确实是不知道多少个层级，要不也不会去用递归的，烦劳写一下代码。

#4

怎么引用啊？
我也想引用一下一楼。

#5

引用 4 楼 aoliwen521 的回复:

怎么引用啊？ 
我也想引用一下一楼。

大哥，右下角不是有引用二字吗？

#6

理论是这样的：任何一个递归算法都能等效的转换为非递归算法...至于这个命题的逆命题我不记得是否成立了

#7

楼主的问题没有意义，不实用

递归转循环，是因为递归比较难理解，并且结构复杂开销也大，唯一可取之处就是代码简洁

既然已经是循环了，还要转换成麻烦的递归？况且楼主的代码已经不用简化了

#8

试着写了一下，大家看看算不算递归

void fx(int x, int y, int z){
  if(x<10){
    fy(x,y,z);
    fx(x+1,y,z);
  }
}
void fy(int x, int y, int z){
  if(y<10){
    fz(x,y,z);
    fy(x,y+1,z);
  }
}
void fz(int x, int y, int z){
  if(z<10){
    System.out.println(""+x+y+z);
    fz(x,y,z+1);
  }
}
fx(0,0,0);

#9

就这样就可以了！呵呵

#10

引用 8 楼 fosjos 的回复:

试着写了一下，大家看看算不算递归 

Java codevoid fx(int x, int y, int z){
  if(x<10){
    fy(x,y,z);
    fx(x+1,y,z);
  }
}
void fy(int x, int y, int z){
  if(y<10){
    fz(x,y,z);
    fy(x,y+1,z);
  }
}
void fz(int x, int y, int z){
  if(z<10){
    System.out.println(""+x+y+z);
    fz(x,y,z+1);
  }
}
fx(0,0,0);

改完后发现确实不好理解，呵呵。

#11

从理论上讲（实际上也是这样，只不过是时间问题罢了），任何循环都可以改成递归；任何递归都可以改成循环。

#12

for(int x=0;x <10;x++) 
{ 
for(int y=0;y <10;y++) 
{ 
  for(int z=0;z <10;z++) 
  { 
  System.out.println(""+x+y+z); 
  } 
} 
}

#13

改过以后的代码没有循环好懂。

#14

引用 11 楼 hepeng19861212 的回复:

从理论上讲（实际上也是这样，只不过是时间问题罢了），任何循环都可以改成递归；任何递归都可以改成循环。

个人习惯问题,喜欢用哪个就用哪个啊,呵呵.

#15

引用 8 楼 fosjos 的回复:

试着写了一下，大家看看算不算递归 

Java codevoid fx(int x, int y, int z){
  if(x<10){
    fy(x,y,z);
    fx(x+1,y,z);
  }
}
void fy(int x, int y, int z){
  if(y<10){
    fz(x,y,z);
    fy(x,y+1,z);
  }
}
void fz(int x, int y, int z){
  if(z<10){
    System.out.println(""+x+y+z);
    fz(x,y,z+1);
  }
}
fx(0,0,0);

這個好像不算遞歸，這個好像應該這樣改：

private static void uu(int x,int y,int z){

System.out.print("\t"+x+y+z);

z++;
if (z==10){
y++;
z=0;
System.out.println();
if (y==10){
x++;
y=0;
System.out.println();
if (x==10){
　　return;　　//遞歸結束後要返回
}
}
}

uu(x,y,z);

}

#16

可以的，不是循环也是可以变成递归的，lz熟悉栈吗？好好研究研究就知道任何程序都可变成递归的意义了

#17

引用 7 楼 fosjos 的回复:

楼主的问题没有意义，不实用

递归转循环，是因为递归比较难理解，并且结构复杂开销也大，唯一可取之处就是代码简洁

既然已经是循环了，还要转换成麻烦的递归？况且楼主的代码已经不用简化了

感 觉和三层for循环一样啊

#18

感觉递归理解起来好难

#19

public static void main(String args []){
  function(3,0);
}
/**
  * level 循环嵌套的层数，本题是3层循环
  * sum   初始值要设置成0
 */
private static void function(int level,int sum){
  for(int i=0;i<10;i++){
    if(level<=0)System.out.println(""+i+sum);
    else function(level-1,sum+i);
  }
}

#20

一直就不会用递归，只能看懂别人用的递归！

#21

晕，遍历2叉树也能用循环搞定吗？我还得好好研究一下。

#22

引用 7 楼 fosjos 的回复:

楼主的问题没有意义，不实用 

递归转循环，是因为递归比较难理解，并且结构复杂开销也大，唯一可取之处就是代码简洁 

既然已经是循环了，还要转换成麻烦的递归？况且楼主的代码已经不用简化了 

在实际应用中，在运行前无法得知循环的层数，所以我想用递归来解决。

#23

引用 8 楼 fosjos 的回复:

试着写了一下，大家看看算不算递归 

Java codevoid fx(int x, int y, int z){
  if(x<10){
    fy(x,y,z);
    fx(x+1,y,z);
  }
}
void fy(int x, int y, int z){
  if(y<10){
    fz(x,y,z);
    fy(x,y+1,z);
  }
}
void fz(int x, int y, int z){
  if(z<10){
    System.out.println(""+x+y+z);
    fz(x,y,z+1);
  }
}
fx(0,0,0);

如果我有5层循环，6层循环，还要多写几个函数吗？

#24

应该可以的吧？

#25

引用 15 楼 sky663 的回复:

引用 8 楼 fosjos 的回复:
试着写了一下，大家看看算不算递归 

Java codevoid fx(int x, int y, int z){ 
  if(x <10){ 
    fy(x,y,z); 
    fx(x+1,y,z); 
  } 
} 
void fy(int x, int y, int z){ 
  if(y <10){ 
    fz(x,y,z); 
    fy(x,y+1,z); 
  } 
} 
void fz(int x, int y, int z){ 
  if(z <10){ 
    System.out.println(""+x+y+z); 
    fz(x,y,z+1); 
  } 
} 
fx(0,0,0); 
 


這個好像…

如果我有多层循环呢？

#26

看情况定吧，lz的代码实在不适合递归

#27

我的解决方案，不太完美，供参考。
class Digui{
static StringBuffer sb=new StringBuffer();
public static void dg(int a)
{
if(a!=0)
{
for(int i=0;i<10;i++)
{
sb.append(i);
dg(a-1);
sb.deleteCharAt(sb.length()-1);
}
}
else
{
System.out.println(sb.toString());
}
}
public static void main(String args[]) {
dg(3);
}
}

#28

引用 19 楼 preferme 的回复:

Java code
public static void main(String args []){
  function(3,0);
}
/**
  * level 循环嵌套的层数，本题是3层循环
  * sum   初始值要设置成0
 */
private static void function(int level,int sum){
  for(int i=0;i<10;i++){
    if(level<=0)System.out.println(""+i+sum);
    else function(level-1,sum+i);
  }
}

学习了，但是得不到想要的结果啊。

#29

还是要根据具体情况而定，两种方法都有个自的优缺点，没必要刻意去使用哪种方法

#30

參考一下這貼,我的回覆在32樓
http://topic.csdn.net/u/20081007/22/94a2f676-cc57-40c9-bb9e-c5b8994e1e5d.html

#31

循环是一种程序结构，递归是方法的一种调用方式。
两者是两个方面的问题。


循环结构，可以采用方法的递归调用来实现。
方法的递归调用，可以采用循环结构配合着栈的使用来实现。