将一整数逆序后放入一数组中（要求递归实现） Ex : 1234 变为 {4,3,2,1}
     */

    static int revert(int rs[], int i, int number) {
        if (i < rs.length) {
            rs[i] = number % 10;
            number = (number - number % 10) / 10;
            return revert(rs, i + 1, number);
        } else {
            return 0;
        }

    }
本人菜鸟一枚，最近自学到关于递归方面的知识，一直在看例子，看到这个一直没想通，求大神帮忙解释下，或者有没有什么好的关于递归的资料。不胜感激

1. package com.hmtest.demo;
   
2. /**
   
3. * 将一整数逆序后放入一数组中（要求递归实现） Ex : 1234 变为 {4,3,2,1}
   
4. *
   
5. */
   
6. public class diguiDemo1 {
   
7. 
   
8.         public static void main(String[] args) {
   
9.                
   
10.                
    
11.                 //定义的数组，可以看做是一个装东西，以备定义的方法用
    
12.                 int [] rs = new int [5];
    
13.                 //定义一个整形数组，接收返回值
    
14.                 int [] arr = revert(rs,0,54321);
    
15.                 //遍历数组
    
16.                 for (int i = 0; i < arr.length; i++) {
    
17.                         System.out.print(arr[i]);
    
18.                 }
    
19. 
    
20.         }
    
21.         //定义方法：1返回值类型为整形数组，参数为传入整形数组,用于保存逆序后的数字;
    
22.         //i,可以用来作为数组的角标，
    
23.         //number为传入的需要逆序的整数
    
24.           static int []  revert(int rs[], int i, int number) {
    
25.                   //判断方法执行的条件
    
26.                 if (i < rs.length) {
    
27.                         //一个数字模于10，得到整数的最后一位数
    
28.                     rs[i] = number % 10;
    
29.                     //此时是略去最后一位数的整数
    
30.                     number = (number - number % 10) / 10;
    
31.                     //递归，将以上重新运算的结果再传入函数
    
32.                     return revert(rs, i + 1, number);//当if条件不满足时就结束方法
    
33.                 } else {
    
34.                     return rs;
    
35.                 }
    
36. 
    
37.             }
    
38. }
    

复制代码

1. import java.util.Iterator;
   
2. 
   
3. public class DiGuiDemo {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 /*
   
10.                  * 递归：其实就是功能的重复使用，但是每次该功能被调用参数都变化(使用了上一次运算的结果)。
    
11.                  * 1，函数自身调用自身。
    
12.                  * 2，一定要定义条件，否则.StackOverflowError。栈溢出。
    
13.                  * 3，注意：递归次数过来容易溢出。
    
14.                  *
    
15.                  */
    
16.                 int sum = getSum(8000);// 4 3 2 1
    
17.                 System.out.println("sum="+sum);
    
18.         }
    
19.         public static int getSum(int num){
    
20.                 if(num == 1){
    
21.                         return 1;
    
22.                 }
    
23.                 return num + getSum(num - 1);
    
24.         }
    
25. }
    

复制代码

//利用递归求十进制的二进制变现形式
        private static void toBin(int num) {
                if (num>0) {
                                toBin(num/2);
                                System.out.println(num%2);                       
                       
                }

//用递归实现求和
        private static int  getSum(int n) {

                if (n==1)
                       
                return 1;
               
                return n+getSum(n-1);       
       
        }



http://blog.csdn.net/anyway1919/article/details/48491445

大概就是这个过程

用递归把整数逆序转换成数组

1. class Test {
   
2.         public static void main(String[] args){
   
3.                 int a = 1234560;
   
4.                 int[] as = new int[16]; //对于一个整型整数，足够了
   
5.                 int count = getNum(as, 0, a); //获取整数多少位，也就是数组中的有效元素个数
   
6.                 System.out.println("count : "+count);
   
7.                 for(int i =0; i<count; i++){
   
8.                         System.out.print(as[i]+ "\t");
   
9.                 }
   
10.         }
    
11.         public static int getNum(int[] as, int index, int num){
    
12.                 if(num == 0){ //等于代表全部取完
    
13.                         return 0;
    
14.                 }
    
15.                 if(index<as.length){
    
16.                         as[index++] = num%10; //把当前num的个位数存入数组中
    
17.                         return 1+getNum(as, index, num/10); //继续把剩下数的存入数组，+1代表已存一个元素
    
18.                 }else{
    
19.                         return 0;
    
20.                 }
    
21.         }
    
22. }

复制代码