关于递归谁能给我一个很好的解释 什么叫递归.毕老师没有讲到
能举个例子吗?

比较典型的例子像阶乘还有拷贝文件时就需要用到递归的思想：
  递归算法，也就是调用方法自身。阶乘算法，N的阶乘为N*(N-1)*...*2*1，1的阶乘是1。

下面是阶乘的例子:

package com.cqit.edu.test;

import java.util.Scanner;

public class Useself {

/**
  * @param args
  */

public static long maths(int n) {

  long num = 0;

  if (n == 1) {

   num = 1;
  } else {

   num = n * maths(n - 1);
  }

  return num;
}

public static void main(String[] args) {
  
  System.out.println("＝＝＝＝＝＝＝＝＝＝＝＝＝递归算法演示＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝");
  System.out.println("请输入n值:");
  Scanner scanner = new Scanner(System.in);
  int n = scanner.nextInt();
  System.out.println(n + "调用递归算法计算阶乘的结果是：" + Useself.maths(n));

自己调用自己啊，说起来简单，做起来不太容易。比如求n！阶乘之类

这里给你一个常见的关于数列的递归：

1. 
   
2. /*
   
3. 斐波那契数列指的是这样一个数列：1、1、2、3、5、8、13、21、...
   
4. 这个数列从第三项开始，每一项都等于前两项之和。
   
5. */
   
6. public class RecursionDemo_02
   
7. {
   
8.         public int compute(int n)
   
9.         {
   
10.                 if(1==n||2==n)
    
11.                 {
    
12.                         return 1;
    
13.                 }
    
14.                 else
    
15.                 {
    
16.                         return compute(n-2)+compute(n-1);
    
17.                 }
    
18.         }
    
19.        
    
20.         public static void main(String[] args)
    
21.         {
    
22.                 RecursionDemo_02 demo=new RecursionDemo_02();
    
23.                
    
24.                 System.out.println(demo.compute(10));
    
25.         }
    
26. }
    

复制代码

你冤枉毕老师了，毕老师讲到这个知识了，你可以看看第20天的视频

/*
列出指定目录下文件或者文件夹，包含子目录中的内容
也就是列出指定目录下所有内容

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。
这种表现形式，或者编程手法，称为递归。
*/
import java.io.*;

class FileDemo3
{
        public static void main(String[] args)
        {
                File dir = new File("d:\\JAVA");
                showDir(dir,0);
               
        }

        public static String getLevel(int level)
        {
                StringBuilder sb = new StringBuilder();
                sb.append("|--");
                for(int x=0; x<level; x++)
                {
                        //sb.append("|--");
                        sb.insert(0,"|  ");
                }
                return sb.toString();

        }
        public static void showDir(File dir, int level)
        {
                System.out.println(getLevel(level)+dir.getName());
                level++;
                File[] files = dir.listFiles();

            for(int x=0; x <files.length; x++)
                {
                        if (files[x].isDirectory())
                                showDir(files[x],level);
                        else
                                System.out.println(getLevel(level)+files[x]);
                       
                }
        }
}

1. 
   
2. public class test1 {
   
3.         public static void main(String[] args){
   
4.         System.out.println(getSum(5));
   
5.         }
   
6.         public static int getSum(int n)
   
7.         {
   
8.                 if(n==1)
   
9.                         return 1;
   
10.                 return n+getSum(n-1);
    
11.         }
    
12. }

复制代码

这就是很简单的一个递归，自己调用自己，毕老师讲的视频里面有一小节是专门讲递归的，就是在第20天的视频里，你可以找一下

public void getList(String filepath) {
                File f = new File(filepath);
                if(f.exists() && f.isDirectory()){
                  File[] addFile = f.listFiles();
                   for(int j=0;j<addFile.length;j++){
                     if(addFile[j].isDirectory()){
                             getList(addFile[j].getAbsolutePath());
                      }else{
                         if(addFile[j].isAbsolute()){
                                 list.add(addFile[j].getAbsolutePath());
                                }
                       }
                       System.out.println(delFile[j]);
                   }
               }
           }

以上是个简单的遍历文件的递归算法！

递归说白了 ，就是自己调用自己，一层层的。用上一个调用的结果给下一个调用做参数~！

Destiny 发表于 2012-3-3 20:48
递归说白了 ，就是自己调用自己，一层层的。用上一个调用的结果给下一个调用做参数~！ ...

不一定是上一个调用的结果，也可以是中间的其他元素，如，在杨辉三角中，求m行，m列的元素数值,cont=f(m-1,n-1)+f(m-1,n),用递归不需要追究它具体怎么做了，只要你写出了争取的程序，它就会给你一个正确的答案的