第四章 面向对象（上）3-类的结构之二：-3.6 递归方法

1.定义：
递归方法：一个方法体内调用它自身

2.如何理解递归方法？
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

3.举例：

//例题1：计算1-100之间的所有的自然数和
int sum = 0;
for(int i = 0;i < 100; i++){
  sum += i;
}
System.out.println("总和为：" + sum );
System.out.println("***************");

//方法二：调用使用递归方法；
RacursionTest test = new RacursionTest();
int sum1 = test.getSum1(100);
System.out.println(sum1);
System.out.println("****************");

//测试例题3：
int value = test.f(10);
System.out.println(value);
System.out.println("*****************");

//测试例题4：
//方法一：
int fib = test.Fibonacci(5);

//方法三：
long fib3 = test.Fibonacci(3);  //[1,1,2]
System.out.println(fib3);    //2
}

//例题1：递归。  计算1-100之间的所有自然数
public int getSum(int num){
  if(num == 1){
    return 1;
  }else {
    return num + getSum(num - 1);
  }

}

//例题2：计算1-100之间所有的自然数乘积    //n！= n * (n-1) * (n-2) * ... * 2 * 1;
public int getSum1(int num){
  if(num == 1){
    return 1;
  }else {
    return num * getSum1(num - 1);
  }

}

//例题3： 已知有一个数列：f(0) = 1, f(1) = 4, f(n+2) = 2*f(n+1) + f(n);
public int f(int n){
  if(n == 0){
    return 1;
  }else if(n == 1){
    return 4;
  }else {
    return 2*f(n-1) + f(n-2);
  }

}

//例题4：斐波那契数列
/*
 * 输入一个数据n，计算斐波那契数列（Fibonacci）的第n个的值
 * 1 1 2 3 5 8 13 21 34 55
 * 规律：一个数等于前两个数之和
 * 要求：计算斐波那契数列的第n个值，并将其数列打印出来
 */
//方法一：
public int Fibonacci(int n){
  if(n == 1 || n == 2){
    return  1;
  }else if(n > 2){
    return Fibonacci(n-1) + Fibonacci(n-2);
  }else{
    return -1;
  }

}

//方法二： 通过for循环实现
public long Fibonacci2(int n ){
  if(n < 1){
    return -1;
  }else if(n == 1 || n == 2){
    return 1;
  }
  
  long a = 1l, b = 1l, c = 0l;
  for(int = 2; i < n;i++){
  c = a + b;      //第3个数的值等于前两个数的和
  a = b;          //第2个数的值赋给第1个数
  b = c;          //第3个数的值赋给第2个数，作为下次循环的基础

  }
return c;
}

//方法三：通过for循环和数组的方式实现
public long Fibonacci3(int n){
  if(n < 1){
    return -1;
  }else if(n == 1 || n == 2){
    return 1;
  }
  long[] arr = new long[n];
  arr[0] = arr[1] = 1;
  for(int = 2; i < n; i++ ){
  arr[i] = arr[i-1] + arr[i-2];
  }
  //可以得到整个的数列数据 仅n > 2
  System.out.println(Arrays.toString(arr));
  return arr[n-1];
}

//例题5：汉诺塔问题

public class TxGame1 {
    /**
     * 一共走了多少步
     */
    static int times;
 
    public static void main(String[] args) {
        char A = 'A';
        char B = 'B';
        char C = 'C';
        System.out.println("汉诺塔游戏开始啦");
        System.out.println("请输入盘子数：");
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        //调用汉诺塔
        hannoi(n, A, B, C);
        s.close();
 
    }
    /**
     * 盘子移动
     * @param disk
     * @param M
     * @param N
     */
    public static void move(int disk, char M, char N ){
        System.out.println("第"+(++times)+"次移动, 盘子"+disk+ "  "+M+"------->"+N);
    }
 
 
    public static void hannoi(int n, char A, char B, char C){
        if(n == 1){
            move(n, A, C);
        }else{
            //移动上一关的步骤移动到B
            hannoi(n - 1, A, C, B);
            //把最大的盘子移动C塔
            move(n, A, C);
            //再把B上的上一关的盘子移动到C上就可以了
            hannoi(n - 1, B, A, C);
 
        }
    }
}

//例题6：快排

public class QuickSort {
    public static void quickSort(int[] arr,int low,int high){
        int i,j,temp,t;
        if(low>high){
            return;
        }
        i=low;
        j=high;
        //temp就是基准位
        temp = arr[low];
 
        while (i<j) {
            //先看右边，依次往左递减
            while (temp<=arr[j]&&i<j) {
                j--;
            }
            //再看左边，依次往右递增
            while (temp>=arr[i]&&i<j) {
                i++;
            }
            //如果满足条件则交换
            if (i<j) {
                t = arr[j];
                arr[j] = arr[i];
                arr[i] = t;
            }
 
        }
        //最后将基准为与i和j相等位置的数字交换
         arr[low] = arr[i];
         arr[i] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }
 
 
    public static void main(String[] args){
        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
        quickSort(arr, 0, arr.length-1);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

标签：arr,return,递归,int,System,3.6,面向对象,println,public
来源： https://www.cnblogs.com/anjiaxiaopihai/p/16286867.html