一道算法题,有会的可以一起讨论下

const data = {

    name: 'A',
    child: [{
            name: 'AB',
            child: [{
                    name: 'AABA'
                },
                {
                    name: 'AABB'
                }
            ]
        },
        {
            name: 'AC',
            child: [{
                    name: 'AACA'
                },
                {
                    name: 'AACB'
                }
            ]
        }
    ]
}
// 请自行封装一个findPath的函数,实现如下效果
// 调用示例

findPath('AABB'); //["A", "AB", "AABB"]

findPath('AABA'); //["A", "AB", "AABA"]

findPath('AACB'); //["A", "AC", "AACB"]

findPath('AC'); //["A", "AC"]

findPath('AACA'); //["A", "AC", "AACA"]

阅读 656
评论
    4 个回答
    • 8.3k

    这种算法最适合用递归吧

    const findPath = (name, data, result = []) => {
      let _result;
      for (const item of data) {
        if (item.name === name) {
          return [...result, item.name];
        } else if (item.child) {
          _result = findPath(name, item.child, [...result, item.name]);
          if (_result) {
            return _result;
          }
        }
      }
    };
    
    findPath('AACB', [data]);

    @李十三 的观点很好,直接判断键名就能拿到结果了,只需一次计算,如果需要多次调用应该是最优解

    const dataReduce = (data, parent = [], result = {}) => {
      data.forEach(item => {
        result[item.name] = [...parent, item.name];
        item.child && dataReduce(item.child, result[item.name], result);
      });
      return result;
    };
    
    const _data = dataReduce([data]);
    
    _data['AACB'];//["A", "AC", "AACB"]