Fork me on GitHub

关于递归-树状结构

发表于 | 更新于: | 分类于
字数统计: 422 | 阅读时长 ≈ 2

关于需求

树状结构数据，需要为每一层增加一个索引值，第一层数据1，第二层2，以此类推；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

var tree = [{
    a: 1,
    children: [{
        a: 1,
        children: [{
            a: 1,
        }]
    }]
}, {
    a: 1,
    children: [{
        a: 1,
        children: [{
            a: 1,
        }]
    }]
}]

具体结果看下代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
var tree = [ {
    count:1,
    a: 1,
    children: [{
    count:2,
        a: 1,
        children: [{
            a: 1,
            count:3,
        }]
    }]
}, {
    count:1,
    a: 1,
    children: [{
    count:2,
        a: 1,
        children: [{
            a: 1,
            count:3,
        }]
    }]
}]

关于解决思路

思路1

树状结构需要层层设置，一般想到的就是递归，关于count设置一个全局变量，递归一层，加一次；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var count = 0;


function fn1(arr) {
    count++
    for (var i = 0; i < arr.length; i++) {
        arr[i].count = count;
        if (arr[i].children) {
            fn1(arr[i].children)
        }
    }
}
fn1(arr)
console.log(arr)

但是递归的顺序并非我们想要的那种，count++执行的时间和想要的不一致

思路2

模拟for循环实现结构，考虑再次更改为递归

1
2
3
4
5
6
7
8
9
for (var i = 0; i < arr.length; i++) {
    arr[i].count = 1;
    if (arr[i].children) {
        for (var k = 0; k < arr[i].children.length; k++) {
            // console.log(arr)
            arr[i].children[k].count = 2;
        }
    }
}

这是实现的基本思路，里面赋值的count可以理解为在for循环这个作用域内，是不改变的，每次递归一次，增加1,通过自执行函数缓存count，每次递归加1

更改版本

1
2
3
4
5
6
7
8
9
10
function fn(arr, c) {
    for (var i = 0; i < arr.length; i++) {
        arr[i].c = c;
        if (arr[i].children) {
            (function(c) {
                fn(arr[i].children, c += 1)
            })(c)
        }
    }
}