递归

一.概念

直接或间接地调用自身的算法称为递归算法。用函数自身给出定义的函数称为递归函数。

二.实例

1.阶乘

public class Factorial {

    public static void main(String[] args) {
        System.out.println(factorial(3));
    }

    public static int factorial(int n) {
        if (n == 1) {
            return 1;
        }
        return n * factorial(n - 1);
    }
}

2.Fibonacci数列
无穷数列1,1,2,3,5,8,13,21….称为Fibonacci即斐波那契数列。

public class Fibonacci {

    public static void main(String[] args) {
        System.out.println(fibonacci(5));
    }

    public static int fibonacci(int n) {
        if (n <= 1) {
            return 1;
        } else {
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
    }
}

3.汉诺塔

/**
 * 汉诺塔问题 有abc三座塔，在a上叠有n个圆盘，自下而上递减 要把a上的n个圆盘移动到b上并满足: 任意时刻大的圆盘不能在小的圆盘上面
 * 每次只能移动一个圆盘
 * 
 * @author sisheng
 *
 */
public class Hanoi {

    public static void main(String[] args) {
        hanoi(2, 'a', 'b', 'c');
    }

    public static void hanoi(int n, char a, char b, char c) {
        if (n == 1) {
            System.out.println("a-->b");
        } else {
            hanoi(n - 1, a, c, b);
            // move(a,b);
            System.out.println("盘" + n + "从" + a + "塔唯一的圆盘移动到" + b + "塔");
            hanoi(n - 1, c, b, a);
        }
    }
}

4.整数划分问题

/**
 * 整数划分问题
 * 
 * @author sisheng
 *
 */
public class IntegerDivision {
    public static void main(String[] args) {
        System.out.println(integerDivide(6,7));
    }

    public static int integerDivide(int n, int m) {
        if (n < 1 || m < 1) {
            return 0;
        }
        if (n == 1 || m == 1) {
            return 1;
        }
        if (n < m) {
            return integerDivide(n, n);
        }
        if (n == m) {
            return integerDivide(n, m - 1) + 1;
        }
        return integerDivide(n - m, m) + integerDivide(n, m - 1);
    }
}

5.全排列问题

/**
 * 全排列问题
 * @author sisheng
 *
 */
public class Perm {

    public static void main(String[] args) {
        String[] array = { "a", "b", "c" };
        perm(array, 0, 2);
    }

    /**
     * 产生list[k:m]的所有排列
     * 
     * @param list
     * @param k
     * @param m
     */
    public static void perm(Object[] list, int k, int m) {
        if (k == m) { // 递归到只剩下一个元素,也就是说只剩下一种排列，直接输出
            for (int i = 0; i <= m; i++) {
                System.out.print(list[i]);
            }
            System.out.println();
        } else {
            for (int i = k; i <= m; i++) {
                swap(list, k, i);
                perm(list, k + 1, m);
                swap(list, k, i);
            }
        }
    }

    /**
     * 交换list[k]与list[m]
     * 
     * @param list
     * @param k
     * @param m
     */
    public static void swap(Object[] list, int k, int m) {
        Object temp;
        temp = list[k];
        list[k] = list[m];
        list[m] = temp;
    }
}