js高级特性:递归

递归调用

反复调用自身的函数。

用递归来解题：

        1、整体思路可以分解为多个相同或相似的思路。

        2、必须有终指条件。

以下都是日常见到和练习用递归解题的总结：

 累加：1+2+3+4...n

console.log(
            aa(100)
        )

        function aa(n) {
            if (n == 1) {
                return 1;
            } else {
                return n + aa(n - 1);
            }
        }

斐波那契数列

求1,1,2,3,5,8,13,21,34,55,89...求第n个位置的值

斐波那契数列的规则是：从第3位开始，每一位都是前两位之和。

     console.log(
                aa(8)  // 输出第几位的值
            )

        function aa(n) {
            if (n == 1 || n == 2) {
                return 1;
            } else {
                return aa(n - 1) + aa(n - 2);
            }
        }

计算 1 +1/2 -1/3+1/4...n

    console.log(
                fn(20)
            );

        function fn(n) {
            if (n == 1) {
                return 1;
            }
            if (n % 2 == 0) {
                return 1 / n + fn(n - 1);
            } else {
                return -1 / n + fn(n - 1);
            }
        }

爬楼梯

假如楼梯有 n 个台阶，每次可以走 1 个或 2 个台阶，请问走完这 n 个台阶有几种走法

     console.log(
                 fn(5)
             )；    

        function fn(n) {
            if (n == 1) {
                return 1;
            }
            if (n == 2) {
                return 2;
            }
            return fn(n - 1) + fn(n - 2);
        }

求1，2，3，...到n的阶乘

    console.log(
                fn(3)
            );

        function fn(n) {
            if (n == 1) {
                return 1;
            }
            return fn(n - 1) * n;
        }

二分数列 

const arr = [1, 5, 6, 3, 2, 4, 8, 9, 7];

        console.log(fn(arr).join(','));

        function fn(arr) {
            // 如果得到的数组长度大于1，则需要继续拆分
            if (arr.length > 1) {
                // 得到中间值的索引
                const index = Math.floor(arr.length / 2);
                // 建立两个空数组，一个是放比中间大的数，一个是放比中间小的数
                const arrMin = [];
                const arrMax = [];
                // 遍历原始数据
                for (let i = 0; i < arr.length; i++) {
                    // 如果遍历到中间值那么就跳过中间值的验证
                    if (i == index) {
                        continue;
                    }
                    // 让数组里面的值和中间值比较
                    if (arr[i] > arr[index]) {
                        // 放比中间值大的数
                        arrMax.push(arr[i]);
                    } else {
                        // 放比中间值小的数
                        arrMin.push(arr[i]);
                    }
                }
                // 返回数据的组合
                return fn(arrMin).concat(arr[index], fn(arrMax));
            } else {
                // 如果数组的长度小于1则直接返回数组
                return arr;
            }
        }