js如何获取tree型数组的最大深度呢？

Question

js如何获取tree型数组中当前项的最大深度呢？

const treeData = [
    {
        key: 'tree1',
        children: [
            {
                key: 'tree2',
                children: [
                    {
                        key: 'tree3',
                        children: [
                            {
                                key: 'tree4'
                            }
                        ]
                    }
                ]
            },
            {
                key: 'tree5'
            }
        ]
    },
    {
        key: 'tree6'
    },
    {
        key: 'tree7'
    }
]

想获得的结果

console.log(getMaxDepthByKey('tree1',treeData))  结果为3
console.log(getMaxDepthByKey('tree2',treeData))  结果为2
console.log(getMaxDepthByKey('tree3',treeData))  结果为1
console.log(getMaxDepthByKey('tree4',treeData))  结果为0
console.log(getMaxDepthByKey('tree5',treeData))  结果为0
console.log(getMaxDepthByKey('tree6',treeData))  结果为0
console.log(getMaxDepthByKey('tree7',treeData))  结果为0

Answer 1

经典的深度优先搜索，只有一个数据么，如果是的话，可以预处理下：

let ans = {}

function getMaxDepthByKey(treeData) {
  for (let item of treeData) {
    getDepth(item)
  }

  function getDepth(obj) {
    if (obj.hasOwnProperty('children')) {
      ans[obj.key] = 0
      for (let item of obj.children)
        ans[obj.key] = Math.max(ans[obj.key], getDepth(item) + 1) 
      return ans[obj.key]
    } else {
      ans[obj.key] = 0
      return 0
    }
  }
}

getMaxDepthByKey(treeData)

console.log(ans['tree1']) // 3
console.log(ans['tree2']) // 2
console.log(ans['tree3']) // 1
console.log(ans['tree4']) // 0
console.log(ans['tree5']) // 0
console.log(ans['tree6']) // 0
console.log(ans['tree7']) // 0

但是题主对调用方式做了固定，稍微改下即可

Answer 2

参照楼上的修改了一下，嘻嘻

var deep = 0;
function getMaxDepthByKey(str, data) {
    for (var i = 0; i < data.length; ++i) {
        if (str === data[i].key) {
            deep = getDeep(data[i]);
            break;
        } else {
            if (data[i].hasOwnProperty('children')) {
                getMaxDepthByKey(str, data[i].children);
            }
        }
    }
    return deep;
}
var maxLen = [];
function getDeep(data) {
    if (data.hasOwnProperty('children')) {
        maxLen[data.key] = 0;
        for (let item of data.children)
            maxLen[data.key] = Math.max(maxLen[data.key], getDeep(item) + 1);
        return maxLen[data.key];
    } else {
        return 0;
    }
}
console.log(getMaxDepthByKey('tree1', treeData));//3
console.log(getMaxDepthByKey('tree2', treeData));//2
console.log(getMaxDepthByKey('tree3', treeData));//1
console.log(getMaxDepthByKey('tree4', treeData));//0
console.log(getMaxDepthByKey('tree5', treeData));//0
console.log(getMaxDepthByKey('tree6', treeData));//0
console.log(getMaxDepthByKey('tree7', treeData));//0

Answer 3

手机不太方便大概是这么想的根据树做数组，然后再算

t1
  t2
    t3
      t4
  t5
t6
t7


[
  [t1 t2 t3 t4]
  [t1 t5]
  [t6]
  [t7]
]

更改结构后应该说从思路上会清晰，但速度可能不快

Answer 4

// 我再改改