249 递归:概念,利用递归求1~n的阶乘,利用递归求斐波那契数列,利用递归遍历数据

6.1什么是递归

递归:如果一个函数在内部可以调用其本身,那么这个函数就是递归函数。

简单理解: 函数内部自己调用自己, 这个函数就是递归函数

注意:递归函数的作用和循环效果一样,由于递归很容易发生“栈溢出”错误(stack overflow),所以必须要加退出条件return。

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>
    <script>
        // 递归函数 : 函数内部自己调用自己, 这个函数就是递归函数
        var num = 1;

        function fn() {
            console.log('我要打印6句话');
            if (num == 6) {
                return; // 递归里面必须加退出条件
            }
            num++;
            fn();
        }
        fn();
    </script>
</body>

</html>

6.2 利用递归求1~n的阶乘

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>
    <script>
        // 利用递归函数求1~n的阶乘 1 * 2 * 3 * 4 * ..n
        function fn(n) {
            if (n == 1) {
                return 1;
            }
            // (1)fn(n - 1):就是 (n-1) 的阶乘; (2)n * fn(n - 1):就是 n 乘以 (n-1)的阶乘,也就是 n 的阶乘。
            return n * fn(n - 1);
        }
        console.log(fn(3));
        console.log(fn(4));
        // 详细思路 假如用户输入的是3
        //return  3 * fn(2)
        //return  3 * (2 * fn(1))
        //return  3 * (2 * 1)
        //return  3 * (2)
        //return  6
    </script>
</body>

</html>


6.3 利用递归求斐波那契数列

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>
    <script>
        // 利用递归函数求斐波那契数列(兔子序列)  1、1、2、3、5、8、13、21...
        // 用户输入一个数字 n 就可以求出 这个数字对应的兔子序列值
        // 我们只需要知道用户输入的n 的前面两项(n-1 n-2)就可以计算出n 对应的序列值
        function fb(n) {
            if (n === 1 || n === 2) {
                return 1;
            }
            return fb(n - 1) + fb(n - 2);
        }
        console.log(fb(3));
        console.log(fb(6));
    </script>
</body>

</html>

6.4 利用递归遍历数据

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>

<body>
    <script>
        var data = [{
            id: 1,
            name: '家电',
            goods: [{
                id: 11,
                gname: '冰箱',
                goods: [{
                    id: 111,
                    gname: '海尔'
                }, {
                    id: 112,
                    gname: '美的'
                }, ]
            }, {
                id: 12,
                gname: '洗衣机'
            }]
        }, {
            id: 2,
            name: '服饰'
        }];

        // 我们想要做输入id号,就可以返回的数据对象
        // 1. 利用 forEach 去遍历里面的每一个对象
        function getID(json, id) {
            var o = {}; // 这个o 必须是外层函数的,因为调用的是外层函数。

            json.forEach(function(item) {
                // console.log(item); // 2个数组元素
                if (item.id == id) {
                    // console.log(item);
                    o = item;
                    return o;
                    // 2. 我们想要得里层的数据 11 12 可以利用递归函数
                    // 里面应该有goods这个数组并且数组的长度不为 0
                } else if (item.goods && item.goods.length > 0) {
                    o = getID(item.goods, id);
                    // return o;  // 在这里return o 也一样,不用到最后return。或者内部函授都不返回,直接让外层函数返回也可。
                }
            });
            return o;
        }

        console.log(getID(data, 1)); // {id: 1, name: "家电", goods: Array(2)}
        console.log(getID(data, 2)); // {id: 2, name: "服饰"}
        console.log(getID(data, 11)); // {id: 11, gname: "冰箱", goods: Array(2)}
        console.log(getID(data, 12)); // {id: 12, gname: "洗衣机"}
        console.log(getID(data, 111)); // {id: 111, gname: "海尔"}
    </script>
</body>

</html>

原文地址:https://www.cnblogs.com/jianjie/p/12231962.html

时间: 2024-12-23 00:05:00

249 递归:概念,利用递归求1~n的阶乘,利用递归求斐波那契数列,利用递归遍历数据的相关文章

斐波那契数列高效递归求法

时间:2014.05.19 地点:图书馆 ------------------------------------------------------------------- 一.简述 前面给出了一种斐波那契数列解法的矩阵幂方法,这是最高效的方法,时间复杂度为O(log).正常来说通过递推公式 F(n)=F(n-1)+F(n-2)直接来计算F(n)效率是很差的,因为这里会涉及很多冗余计算,比如求F(5),我们要求[F(4)和F(3)],[要求F(4)则得求F(3)和F(2),要求F(3)得求F

斐波拉契数列的递归、非递归、公式法多种方法实现

实现斐波拉契数列:1,1,2,3,5,8...,当n>=3时,f(n)=f(n-1)+f(n-2). 解:求解斐波拉契数列方法很多,这里提供了4种实现方法和代码,由于第5种数学公式方法代码太过繁琐,只做简单介绍 方法一:递归调用,每次递归的时候有大量重复计算,效率低,可将其调用的过程转化成一颗二叉树进行分析,二叉树的总结点个数不超过(2^n-1)个,由于其是不完全二叉树,那么函数计算的次数必小于(2^n-1),时间复杂度为O(2^n):递归调用的深度为n,空间复杂度为O(n) 方法二:非递归数组

【剑指offer】斐波那契数列(递归和非递归实现)

递归实现是最常想到的方法,代码如下: //递归方式 long Fibonacci(unsigned n) { if (n==0) { return 0; } else if (n==1) { return 1; } else { return Fibonacci(n-1)+Fibonacci(n-2); } } 显然递归并不是最好的方法,当n较大时效率将非常低下. 较好的思路是: 从下往上计算,首先根据f(0)和f(1)算出f(2),再根据f(1)和f(2)算出f(3)--依此类推就可以算出第n

关于斐波那契数列和递归

递归有三个基本点: 1.递归总有一个最简单的情况.即边界或者跳出递归的条件语句: 2.递归总是尝试解决一个规模更小的问题: 3.递归尝试解决的父问题和子问题之间不因该有交集: 以下是几个递归代码://斐波那契数列 import edu.princeton.cs.algs4.StdOut; public class No_1_1_19 { public static void main(String[] args) { for(int n=0;n<10;n++) { StdOut.println(

斐波那契数列和递归实现阶乘

package com.lv.study; public class DemoAm4 { //斐波那契数列:生兔子 :从1和1开始 后面一个数等于前面两个数之和 public static void main(String[] args) { test2(); } public static void test2(){ int num1=1; int num2=1; int result =0;//暂时不知道结果 //推算第5轮结果 int n=5; System.out.print("1\t1

C语言编程实现斐波那契数列(递归与非递归)

一.非递归 <1>数组 #include<stdio.h> #include<stdlib.h> int main() { int a[10000] = { 0 };//利用数组求不了较大位置的斐波那契数 int i,m; a[0] = 1; a[1] = 1; printf("请输入要求第几个斐波那契数(大于等于2)\n"); scanf("%d", &m); for (i = 2; i <=m; i++) { a

c/c++ 斐波那契数列 利用模板元解决递归慢的问题

#include<iostream> //模板元 变成 一般用于递归 游戏开发里常用template<int N>struct data{ enum {res=data<N-1>::res+data<N-2>::res};};template<>struct data<1>{ enum {res=1};};template<>struct data<2>{ enum {res=2};}; int getdata

斐波那契数列的递归和非递归解法

//递归解法 function fib(n){ if(n < 1){ throw new Error('invalid arguments'); } if(n == 1 || n == 2){ return 1; } return fib(n - 1) + fib(n - 2); } //非递归解法 function fib(n){ if(n < 1){ throw new Error('invalid arguments'); } if(n == 1 || n == 2){ return 1

斐波那契数列(递归)c#

我郑重宣布 我爱递归 我自己编程几乎都没用过递归 我看到这个题的时候虽然想到了用递归 但是我个脑残一直在想怎么设置动态数组 明明纯递归更简单 我也是可无语 反正我爱上递归了 爱惹  无法自拔 原文地址:https://www.cnblogs.com/ywfp-lee/p/11774462.html

斐波那契数列的递归实现

兔子在出生两个月后,就有繁殖能力,一对兔子每个月能生出一对小兔子来.假设所有兔子都不会死去,能够一直干下去,那么以后可以繁殖多少对兔子呢? 月数 1 2 3 4 5 6 7 8 9 10 11 12 兔子对数 1 1 2 3 5 8 13 21 34 55 89 144 所以我们找到了规律,从第三个月起,每个月的兔子对数都等于前两个月的兔子对数之和 那么我们用代码来表示 package com.sbtufss.test; public class Test { public static voi