递归方法小综合

使用递归可以简化我们的理解，便于阅读，但是当数据量大的时候会占用较大的内存，所以程序运行的速度会大打折扣。
使用递归需要满足以下条件：
1、有终止条件（记住：递归不是死循环）
2、有递归部分，通俗的就是说，函数直接或间接的调用自身

下面是不同语言下实现的递归程序：
1、C语言使用递归计算数组前N个数的和：

#include<stdio.h>
#incelue<stdlib.h>

sum(int a[],int n)
{
    if(n<=0)
        return 0;
    return a[n-1]+sum(a,n-1);
}
int main()
{
    int i;
    int a[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
    clrscr();
    printf("\n The arry is:\n");
    for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
        printf(" %d ",a[i]);
    printf("\n SUM of the arry is: %d\n",sum(a,sizeof(a)/sizeof(a[0])));
    printf("\n Press any key to quit...\n");
    getch();
    return 0;
}

2、C++使用递归：
要求：一次可以上一个台阶，两个台阶，三个台阶，问共有N个台阶，共有几种方法上去
核心代码：

int P(int x) 
{
    int y=0; 
    if(x==1)
        return 1; 
    else if(x==2)
        return 2; 
    else if(x==3)
        return 3; 
    else 
        return P(x-1) + P(x-2) +P(x-3); 
}

3、Java使用递归实现汉诺塔摆放问题：

package Others;

public class HanoiTest {
static long endTime;
    public static void main(String []args){
        int n=4;
        long currentTime=System.currentTimeMillis();

        Function(n,"A","B","C");
        endTime=System.currentTimeMillis();
        System.out.println("共用时："+(endTime-currentTime)/1000+"秒");
    }
    /*
     * 函数实现的思想其实是递归，也就是说：
     * 1、当n等于1时，直接将A移动到C上
     * 2、先拿C作为过渡，把A上的n-1个移动到B上，然后把A上的最后一个移动到C上，在拿A做过渡，将B上的所有的移动到C上
     * 3、这将会自动的实现递归的过程并解决问题
     */
    public static  void Function(int n,String a,String b,String c){
        if(n==1){
            System.out.println("Move "+ a+" to "+c);
        }else{
            Function(n-1, a, c, b);
            System.out.println("Move "+ a+" to "+c);
            Function(n-1, b, a, c);

        }
    }

}

下面是程序运行结果：

Move A to B
Move A to C
Move B to C
Move A to B
Move C to A
Move C to B
Move A to B
Move A to C
Move B to C
Move B to A
Move C to A
Move B to C
Move A to B
Move A to C
Move B to C
共用时：0秒

总结：
使用递归的思路就是找到最小可控单元，把复杂问题简化成原子问题，对原子问题采用这种简单的方式处理，然后把分散的原子问题通过”递归“的方法串联起来，便可以得到最后的结果。
鉴于我本身能力有限，总结的可能也许不好，还望大家不吝赐教，最后希望我们能够共同进步，一起提高！