冒泡排序，递归，递归深拷贝

随机一个数组 前后对比只有在大于的情况下才往下走 不满足条件时 执行下一个 一组数据需要几次执行完？

let arr = [1000,123,44,22,23243,5456,6788,686,2344,2342]
    let index = 0
    for(let i=0; i<arr.length; i++){
        index = i++
        for(let j=i+1; j<arr.length; j++){
            if(arr[i]>arr[j]){
                arr[i] = arr[j]
                arr.splice(j,1)
            }
        }
    }   
    console.log(index);
    // index	记录执行的次数

总结：双循环 第二循环下标加一 使其数据错开 之后再依次对比 内容覆盖 裁剪 输出执行次数

数组数据相加 求和 返回状态

var arr = [10,1,44,9]  
    function fn(arr){
        for(let i=0; i<arr.length; i++){
            for(let j=i+1; j<arr.length; j++){
                if(arr.includes(arr[i]+arr[j])){
                    return true
                }
            }
        }
        return false
    }   
    console.log(fn(arr));

总结：利用函数可以强行停止 并输出结果的特性 来完成效果 双循环 依次相加并比配结果是否存在

最简单的递归实现原理

function fn (num){
        if(num <= 0){
            return '完成条件数字减到 '+ num  +' 停止递归自我调用'
        }
        return (fn( num-1 ))
    }
    console.log(fn(50));

总结：函数的返回对象 是一条数据 所以可以返回自身并调用 就会进入自我递归形态 如果没有终止条件 就会进入死循环 或者 常见的两个事件相互调用 也会进入死循环 且用且珍惜

递归完成深拷贝

// 递归 完成深拷贝
     const json = [
        {
          id: 1,
          title: "课程1",
          children: [
            { 
                id: 4, 
                title: "课程1-1" 
            },
            {
              id: 5,
              title: "课程1-2",
              children: [
                { 
                    id: 6, 
                    title: "课程1-2-1" 
                },
                { 
                    id: 7, 
                    title: "课程1-2-2" 
                }
              ],
            },
          ],
        },
        { 
            id: 2, 
            title: "课程2" 
        },
        { 
            id: 3, 
            title: "课程3" 
        }
      ];
        var num = 0
    function fn (json) {
        // 创建一个空接收数据 通过判定再添加它的格式
        let newJson = null;
        // 判定数据类型 typeof 判定数据类型时 对复杂数据类型判定结果都为 object 这一特性 这样 数据内部的数组或者对象均可以包括
        if(typeof(json) == 'object' && json !== null){
            // 三木判定 要处理的数据的 instanceof 后的结果 因为 instanceof 可以区分出数组和对象 就可以给创建的 接收器 添加验证后的格式外包裹
            newJson = json instanceof Array ? [] : {}
            // 循环这个数据 如果内部还有复杂数据对象 递归自调用 继续向内执行深拷贝
            for(var i in json){
                newJson[i] = fn(json[i])

            }
        }else{
            // 如果不是复杂类型 直接添加
            newJson = json
        }
        // 把输出的结果返回出去
        return newJson

    }
    // 创建一个新的数据 来接收最后拷贝的数据 一方内容修改 不会影响另一个数据 的数据 深拷贝成功
    let json2 = fn(json)
    json2[2].title = '改了'
    console.log(json,json2);