几个简单的递归函数

递归求解1*2*3*4*5...*n

        设计一个函数，传进入参数n，使函数的返回值为1*2*3*4*5,,,*n的值。这个函数如果不使用递归也可以实现求n的阶乘。

不使用递归实现求n的阶乘函数

  static int factorialNormal(int n) {
        int sum = 1;

        for (int i = 1; i <= n; i++) {
            sum *= i;
        }
        return sum;
    }

使用递归实现求n的阶乘函数

        使用递归函数之前我们肯定需要知道递归的终止条件，在这里我们将限制条件设定为n <= 1,每次执行的操作n-1也就越来越接近这个限制条件。

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

没有返回值的函数慎重使用递归

        如果一个函数没有返回值，在函数中直接使用递归，将可能会造成堆栈溢出的情况。

    static void tail(int n) {
        if(n > 0) {
            System.out.print(n);
        }
        tail(n - 1);
        System.out.print(n);
    }

执行代码

tail(5);

运行结果 

54321Exception in thread "main" java.lang.StackOverflowError
	at com.phy.data.recursion.Main.tail(Main.java:29)
	at com.phy.data.recursion.Main.tail(Main.java:29)
	at com.phy.data.recursion.Main.tail(Main.java:29)
	at com.phy.data.recursion.Main.tail(Main.java:29)
	at com.phy.data.recursion.Main.tail(Main.java:29)
	at com.phy.data.recursion.Main.tail(Main.java:29)
	at com.phy.data.recursion.Main.tail(Main.java:29)
	at com.phy.data.recursion.Main.tail(Main.java:29)
	at com.phy.data.recursion.Main.tail(Main.java:29)

在执行完n>0时的情况下，仍然在递归调用tail(n-1)函数，没有限制条件，导致出现堆栈溢出的异常。

如果在函数中调用多个递归函数

        可以在在函数中调用多个递归函数，执行的操作可以不一样，但限制条件应该一样。

    static String ex237(int n) {
        if (n <= 0) {
            return "";
        }
        return (ex237(n - 3) + n + ex237(n - 2) + n);
    }

        执行代码

System.out.println(ex237(9));

        代码执行过程图 只有第一层和第二层的代码，后面的递归是一样的。

 不同的递归函数一直递归下去，知道达到限制条件，返回“”；

输出结果应该为

311361142246911422472253113579

递归实现1+2+3...+n求和函数

        经过上面的几个函数，实现求和函数就很简单了。

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

递归实现求一个数组中的最小值

        入参a[] 是要求的目的数组，n是目的数组的长度。

    static int min(int a[], int n) {
        if(n == 1) {
            return a[0];
        }
        if (a[0] > a[n - 1]) {
            a[0] = a[n-1];
        }
        return min(a,n - 1);
    }

        函数的逻辑非常简单，拿数组中第一个元素与最后一个元素比较大小，将较小的放在第一个元素的位置，再与倒数第二个元素比较，往复下去，直到将其他元素都与第一个元素比较完后，再返回第一个元素。

递归实现判断字符数组元素是否符合回文的规范

    static boolean isPlindrome(char c[], int n) {
        if (n == 1) {
            return true;
        }
        int m = c.length;
        if (c[m - n] != c[n - 1]) {
            return false;
        } else {
            return isPlindrome(c, n - 1);
        }
    }