编写一个阶乘方法，要求：1、输入一个整数（如：5），返回该数的阶乘（如5！）；
2、返回值类型：int；形参类型：int；

3、必须使用递归。

游客，如果您要查看本帖隐藏内容请回复

1. 
   
2.         public static int recursion(int num) {
   
3.                 if (num == 1) {
   
4.                         return 1;
   
5.                 } else {
   
6.                         return num * recursion(num - 1);
   
7.                 }

复制代码

1. import java.util.Scanner;
   
2. 
   
3. /*
   
4. 1、编写一个阶乘方法，要求：1、输入一个整数（如：5），返回该数的阶乘（如5！）；
   
5. 2、返回值类型：int；形参类型：int；
   
6. 3、必须使用递归。
   
7. */
   
8. public class Question1 {
   
9.         public static void main(String[] args) {
   
10.                 Scanner in = new Scanner(System.in);
    
11.                 int num = in.nextInt();                        //接收一个键盘输入的数字
    
12.                 System.out.println(method(num));
    
13.         }
    
14.         private static int method(int num) {
    
15.                 // 当值为1时直接返回1
    
16.                 if (num == 1) {
    
17.                         return 1;
    
18.                 } else {
    
19.                         // 当值不为1时，将该值减1后进行递归
    
20.                         return method(num - 1) * num;
    
21.                 }
    
22.         }
    
23. 
    
24. }
    

复制代码

flying 发表于 2014-2-22 18:39

这个给力，连IO流都用上了

dongdong5982 发表于 2014-2-22 18:35
话说，用int类型的话，范围有点小吧，很容易超出范围的，改为long的话应该会更好一点
...

倒也对，这个倒没注意

乔青山 发表于 2014-2-22 16:41
主要想递归，至于阶乘，实话实说，写程序之前2的阶乘是1！+2！还是2!我都不知道、、嗯，有的地方会有错 ...

你准备哪一期？

1. public class Test3 {
   
2.         public static void main(String[] args) throws Exception{
   
3.                         BufferedReader bufr =
   
4.                         new BufferedReader(new InputStreamReader(System.in));
   
5.                         while(true){
   
6.                                 int num=Integer.parseInt(bufr.readLine());
   
7.                     System.out.println(fun(num));
   
8.                         }
   
9.                 
   
10.         }
    
11.         public static int fun(int num){
    
12.                 if(num>0){
    
13.                         return num*fun(num-1);
    
14.                 }
    
15.                 else
    
16.                         return 1;
    
17.         }
    
18. }

复制代码

1. public class Factorial {
   
2.         public static void main(String[] args) {
   
3.                 System.out.println(myFactorial(5));
   
4.         }
   
5.         public static int myFactorial(int var) {
   
6.                 // 当值为1时直接返回1
   
7.                 if(var == 1) {
   
8.                         return 1;
   
9.                 } else {
   
10.                         // 当值不为1时，将该值减1后进行递归
    
11.                         return myFactorial(var - 1) * var;
    
12.                 }
    
13.         }
    
14. }
    

复制代码

话说，用int类型的话，范围有点小吧，很容易超出范围的，改为long的话应该会更好一点

徐芾清 发表于 2014-2-22 16:38
哥们，你忘了0！=1注释一下，不是0不等于1啊，是0的阶乘等于1

:L主要想递归，至于阶乘，实话实说，写程序之前2的阶乘是1！+2！还是2!我都不知道、、嗯，有的地方会有错误，阶乘我不大知道

乔青山 发表于 2014-2-22 16:34
//一个数的阶乘递归做
        public  static int recursion(int a){
                if(a==1){

哥们，你忘了0！=1注释一下，不是0不等于1啊，是0的阶乘等于1

//一个数的阶乘递归做
        public  static int recursion(int a){
                if(a==1){
                        return 1;
                }else{
                        return a*recursion(a-1);
                }
        }
       
        //阶乘和递归做（双递归）
        public static int factorial(int a){
                if(a>0){
//                        int b = 1;
//                        for(int i=1;i<=a;i++){
//                                b*=i;
//                        }
                        int b = recursion(a);                                //双递归
                        a=b+factorial(a-1);
                }
                return a;
        }

zengming13 发表于 2014-2-22 16:16

哥们，挺快啊