递归改循环方案，栈溢出的解决方案，用循环遍历未知深度的树形结构

最新推荐文章于 2022-11-12 14:53:54 发布
最新推荐文章于 2022-11-12 14:53:54 发布
阅读量1.2k 收藏 4
点赞数 3
分类专栏： 前端开发 文章标签： javascript 递归算法 前端 堆栈 es6
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29456953/article/details/109542275
版权

递归改循环方案，用循环遍历未知深度的树形结构

在很多时候，我们在遍历的时候会选择用递归来实现，比如深拷贝两个对象，拍平数组啥的，大多数情况下，我们的栈的深度不会太深，使用递归并没用什么问题。

下面，我们来讨论下特殊场景下，如何用循环来代替递归。

递归的一些优缺点

缺点: 1.递归在不同的浏览器，栈溢出的极限值不一样，谷歌78达到3万多，ie11还不到1万
缺点: 2.递归要保存函数的很多信息，理论上来说，空间上是要占用更多的储存空间，执行效率上是会略慢一些（没有实测）
优点: 递归更加通俗易懂（相比较改循环而言）

查看当前浏览器调用栈的长度可以用以下代码

(()=>{
    let maxStackNumber = 0;
    function test() {
        return test(maxStackNumber++)
    }
    try {
        test()
    } catch (err) {
        console.log(maxStackNumber)
    }
})()

如何用递归遍历未知深度的树形结构

我们以实现一个“简单”的深拷贝代码为例（实际业务中会考虑很多类型，本文的重点不在深拷贝如何实现上，在这里我们只考虑最简单的）

(function () {
    function isObj(o) {
        return Object.prototype.toString.call(o)==="[object Object]"
    }
    function isArray(o) {
        return Object.prototype.toString.call(o)==="[object Array]"
    }
    function assign(target,obj) {
        for(let key in obj){
            if(Object.hasOwnProperty.call(obj,key)){
                if(isObj(obj[key])){
                    target[key]=target[key]||{};
                    assign(target[key],obj[key])
                }else if(isArray(obj[key])){
                    target[key]=target[key]||[];
                    assign(target[key],obj[key])
                }else {
                    target[key]=obj[key]
                }
            }
        }
        return target
    }
    const obj1={a:1,b:{c:2}};
    const obj2={a:2,b:{d:3}};
    return assign(obj1,obj2);
})();

如何将上述递归改造成循环？

递归改循环方案

栈中信息模拟

栈中保存函数的信息，如参数，返回值，作用域，函数体

根据具体的使用场景来选择保存哪些信息，这里以深拷贝为例，我们保存以下函数信息

  1. 参数
  2. 函数体中遍历的键集合（因为我们的for循环可能会在中间的时候暂停，进入下一级循环，所以在这里保存遍历的键集合）
  3. 函数体中遍历的键的索引（配合上面的键集合来使用）
class FnData{
    setArgs(...args){//存储参数集合
        this.args=args;
    }
    setKeys(keys){//存储当前对象的键集合
        this.keys=keys
    }
    setIndex(index){//存储遍历位置
        this.index=index
    }
}

进栈出栈模拟

我们使用递归会自动进栈，自动出栈，所以我们需要模拟同样的行为，但for循环是从上至下执行，而递归是从外往内执行，这其实是有本质上的区别，
但我们可以用跳转来实现同样的效果，类似与goto语句，但js没有goto语句，幸运的是这不重要，我们可以用标签来模拟。

function assign(target,obj) {
    //新建是一个栈集合
    const stack = new Array(0);
    //存储上述递归函数的相关信息
    let fnData = new FnData();
    fnData.setIndex(0);
    fnData.setArgs(target,obj);
    fnData.setKeys(Object.keys(obj));
    //将信息推入栈
    stack.push(fnData);
    //while加标签，模拟goto，只要栈内有信息，则一直执行
    outside:
    while (stack.length>0){
        //取出栈顶元素
        let curFnData = stack[stack.length-1];
        let [_target,_obj]=curFnData.args;
        let keys = curFnData.keys;
        //取出栈中遍历的索引,从上次没执行完的地方继续执行
        for(let i=curFnData.index;i<keys.length;i++){
            let key = keys[i];
            //设置当前键已经遍历过，索引后移
            curFnData.setIndex(i+1);
            if(Object.prototype.hasOwnProperty.call(_obj,key)){
                if(isObj(_obj[key])||isArray(_obj[key])){
                    _target[key]=_target[key]||(isArray(_obj[key])?[]:{});
                    //如果是对象，表明我们要进入下一层了，保存所需要的信息
                    let _fnData = new FnData();
                    _fnData.setIndex(0);
                    _fnData.setArgs(_target[key],_obj[key]);
                    _fnData.setKeys(Object.keys(_obj[key]));
                    //入栈
                    stack.push(_fnData);
                    /*
                    * 核心是这个
                    * 我们将下一层的信息推入栈中后，会中断当前的遍历，强制跳转至外层while循环，此时循环体会重新执行，
                    * 而栈顶的信息已经改变，变成了子级，等到子级遍历完毕出栈后，才会继续当前的遍历，
                    * 此时因为我们之前已经保存了索引信息，所以我们可以直接从索引位置开始
                    * */
                    continue outside
                }else {
                    _target[key]=_obj[key]
                }
            }
        }
        //出栈，相当于从子级往外跳一层
        stack.pop()
    }
    return target
}

完整代码

(function () {
    function isObj(o) {
        return Object.prototype.toString.call(o)==="[object Object]"
    }
    function isArray(o) {
        return Object.prototype.toString.call(o)==="[object Array]"
    }
    class FnData{
        setArgs(...args){//存储参数集合
            this.args=args;
        }
        setKeys(keys){//存储当前对象的键集合
            this.keys=keys
        }
        setIndex(index){//存储遍历位置
            this.index=index
        }
    }
    function assign(target,obj) {
        //新建是一个栈集合
        const stack = new Array(0);
        //存储上述递归函数的相关信息
        let fnData = new FnData();
        fnData.setIndex(0);
        fnData.setArgs(target,obj);
        fnData.setKeys(Object.keys(obj));
        //将信息推入栈
        stack.push(fnData);
        //while加标签，模拟goto，只要栈内有信息，则一直执行
        outside:
        while (stack.length>0){
            //取出栈顶元素
            let curFnData = stack[stack.length-1];
            let [_target,_obj]=curFnData.args;
            let keys = curFnData.keys;
            //取出栈中遍历的索引,从上次没执行完的地方继续执行
            for(let i=curFnData.index;i<keys.length;i++){
                let key = keys[i];
                //设置当前键已经遍历过，索引后移
                curFnData.setIndex(i+1);
                if(Object.prototype.hasOwnProperty.call(_obj,key)){
                    if(isObj(_obj[key])||isArray(_obj[key])){
                        _target[key]=_target[key]||(isArray(_obj[key])?[]:{});
                        //如果是对象，表明我们要进入下一层了，保存所需要的信息
                        let _fnData = new FnData();
                        _fnData.setIndex(0);
                        _fnData.setArgs(_target[key],_obj[key]);
                        _fnData.setKeys(Object.keys(_obj[key]));
                        //入栈
                        stack.push(_fnData);
                        /*
                        * 核心是这个
                        * 我们将下一层的信息推入栈中后，会中断当前的遍历，强制跳转至外层while循环，此时循环体会重新执行，
                        * 而栈顶的信息已经改变，变成了子级，等到子级遍历完毕出栈后，才会继续当前的遍历，
                        * 此时因为我们之前已经保存了索引信息，所以我们可以直接从索引位置开始
                        * */
                        continue outside
                    }else {
                        _target[key]=_obj[key]
                    }
                }
            }
            //出栈，相当于从子级往外跳一层
            stack.pop()
        }
        return target
    }
    const obj1={a:1,b:{c:2}};
    const obj2={a:2,b:{d:3}};
    return assign(obj1,obj2);
})();

性能

今天太晚了，改天测试下

总结

一般情况下，我们还是使用递归为佳，因为改循环的方案，就像使用goto一样难受，很对语言不支持goto是有原因的，太难受，跳来跳去很绕，
但如果我们有层级很深或者追求性能的时候，可以尝试将递归改为循环，你就可以跳出系统的限制，自己决定栈的深度。

结束语：如果遇到了问题，欢迎在评论区交流，如果觉得不错，可以点赞和收藏，持续更新。

博客中标注原创的文章，版权归原作者 苦中作乐才是人生巅峰所有；转载或者引用本文内容请注明来源及原作者；

夜深人静写算法（五十）- Dancing Links X（跳舞链）
英雄哪里出来
01-31 32万+
双向十字交叉循环链表求解精确覆盖、重复覆盖。 骨牌覆盖、N皇后问题的高效解法。
《英雄编程体验课》第 14 课 | 题海战术
热门推荐
英雄哪里出来
10-07 4万+
「 让天下没有难学的算法 」
递归转循环
xiazaicsd55的博客
08-05 358
recursion to stack 问题：把一个递归函数转换成非递归，由于数据量导致栈溢出了。 虽然没有看懂被人写的算法，但是看懂了逻辑结构。主要难点是因为函数主题是一个while true的循环，循环体里面是很多个 if 分支，有的分支会return，有的会改变入参a，有的分支会递归调用被改变后的a并在递归结束后做其他操作也及分支判断。 思路再加一层栈不为空的循环； 入栈元素以及元素入...
递归转循环的通用方法
To be what you what to be!
04-18 2万+
1.递归 定义：程序调用自身的编程技巧称为递归。 栈与递归的关系：递归是借助于系统栈来实现的。每次递归调用，系统都要为该次调用分配一系列的栈空间用于存放此次调用的相关信息：返回地址，局部变量等。当调用完成时，就从栈空间内释放这些单元，在该函数没有完成前，分配的这些单元将一直保存着不被释放。 2.递归转化为循环 记得有人说过“所有递归都能转化为循环”，某晚睡不着思考了一下这个问题
十步法将递归程序快速转变成迭代或循环程序
xiaoding133的专栏【Stay hungry,Stay foolish】
03-23 2449
前言：在有些情况下，我们更倾向于使用递归函数，如排序（合并排序）或树相关操作的算法（heapify/ heapify）。但是，递归函数在某些环境中，如在Visual C ++中，如果调用层次过深，可能会出现如堆栈溢出。许多专业的开发人员可能已经知道如何更改递归功能用迭代函数或使用栈（堆栈）和while循环解决（模拟递归的过程）堆栈溢出问题。         如果您使用的是递归函数，因为你不控制调
如何将递归转换为循环
bill的博客
05-30 2296
动机 递归效率没有循环高，有额外的方法调用开销 堆栈溢出（stackoverflow） 递归有时挺难理解（不过很多算法用递归最容易实现） 直接法 首先找到递归的结束条件，并且每次递归调用肯定是逼近结束条件（Base Case） 实现一个相同结束条件的循环，每次循环逼近结束条件 public class CountDown { public void countDown(int n) { if(n == 0) return; System.out.println(n + "...");
递归转for循环
qq_38703193的博客
03-26 1263
面试题中一个递归转for循环的题 原来的递归代码： public static int unsigned(int num){ return (num < 2)? 1:unsigned(num - 1)+unsigned( num-2); } 转换成for循环： public static int unsigned(int num){ List&l...
递归算法优化全攻略：数据结构问题的终极解决方案
![数据结构论文递归]...递归算法是一种在解决问题时，通过函数自身调用自身以解决问题的方法。其基本思想非常简单，即把规模大的问题转化为规模小的相似的子问题来解决。递归算法的基础在于两个关键
【揭秘DFS递归技巧】：数据结构与算法中的递归深度控制与性能优化
![数据结构dfs递归]...递归是计算机科学中一种强大的编程技术，它允许函数直接或间接地调用自身来解决问题。在深入探讨递归算法的理论基础之前，本章旨在为读者打下扎实的基础，让大家对深度
数据结构（从概念到C++实现）
m0_54285007的博客
09-05 6605
目录 第2章 线性表 2.1 引言 2.2 线性表的逻辑结构 2.2.1 线性表的定义 2.2.2 线性表的抽象数据类型定义 第2章 线性表 2.1 引言 线性表是描述单一的前驱和后继的关系 2.2 线性表的逻辑结构 2.2.1 线性表的定义 线性表是一个有限的序列，每个元素有且只有一个前驱和一个 后继，表头和表尾元素分别无前驱和后继。 线性表数据元素的个数称为线性表的长度，长度为0的线性表称为空表 线性表的常用表达方式为：L=(a1,a2,a3,a4....an) 2.2.
递归改循环，防止栈溢出
qq_25775675的博客
07-02 846
使用递归会有栈溢出的问题，这个时候需要把递归改为循环。以下代码演示了递归改循环的方法。并且最后还附加了复制树结构的案例（将Person的树结构，复制为Human树结构）。 import java.util.ArrayList; import java.util.List; import java.util.Stack; class Main { public static void main(String[] args) { // 构建 原始数据 Person
Javascript 树结构数据转换，用循环代替递归防止栈溢出
weixin_34367257的博客
06-29 589
用循环代替递归防止栈溢出 有些场景可能需要我们把平级的数据转换成树结构，例如： let data = [ { id: 1, pid: 0 }, { id: 2, pid: 1 }, { id: 3, pid: 2 }, { id: 4, pid: 3 }, { id: 5, pid: 3 }, ...
递归转化为循环
jeffasd的专栏
06-06 1922
//将递归转化为for循环看例子将递归转为for循环需要求解递归关系,知道递归关系后就可以使用循环来实现。 如下示例 求解后知//f(n) = n * f(n - 1);代码详解如下:/** 求阶乘 */ int factorial(int n){ static int calculateCount = 0; printf("calculate count is %d\n", cal
递归调用转为循环
ssshen14的专栏
02-21 658
背景 有一个接口会返回json格式的字符串，json格式是嵌套的，类似这样的如下的结构，需要转换为一个list，当然最简单的写一个递归就可以了，但是有一句话： “所有的递归都可以转化为循环”，那么就用循环实现吧。 { "respData":[ { "id":1, "isvalid":1, "orgName":"汽车", "parentId":0, "subOrg...
递归训练-循环改递归
qq_36489998的博客
06-04 735
循环改递归package day17; public class 循环改递归 { // 求x的长度 static int f(String x){ if(x.equals("")) return 0; String x2 = x.substring(1); // 甩掉头 return f(x2) + 1; } // 求x是否为镜像串 static b...
用递归方法实现树形列表
qq_54814088的博客
06-02 310
递归实现树形分类结构
关于for循环数据溢出问题
最新发布
༄༊星河༣
11-12 1289
关于for循环数据溢出问题
栈溢出
Leon_Jinhai_Sun的博客
05-17 290
这节课我们讲一下栈溢出,栈溢出主要是在做递归调用的时候,循环定义的情况下,可能会发生一个栈溢出的一个问题,就是抛出 栈异常,也就是一个最大的深度 package com.learn.test; /** * 栈溢出 * 这个你默认的话不一样的 * 最大深度可能跟每个的配置是不一样的 * 这个你无法去说的 * 我记得是1万2千多 * 具体数字我也忘记了 * 我们看一下默认深度是...
递归转变成循环的通解
ruohuanni的专栏
09-18 515
http://www.cnblogs.com/wb-DarkHorse/archive/2013/11/15/3284228.html
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值