你真的会深度遍历和广度遍历吗？

提出问题

如下有一个对象，要求遍历所有的n，分别用深度优先遍历和广度优先遍历？

const tree = {
    n: 'root',
    child: [
        {
            n: 'left-1',
            child: [
                {
                    n: 'left-1-1',
                    child: [
                        {
                            n: 'left-1-1-1',
                            child: []
                        }
                    ]
                },
                {
                    n: 'left-1-2',
                    child: []
                }
            ]
        },
        {
            n: 'right-1',
            child: [
                {
                    n: 'right-1-1',
                    child: []
                },
                {
                    n: 'right-1-2',
                    child: [
                        {
                            n: 'right-1-2-1',
                            child: []
                        }
                    ]
                }
            ]
        }
    ]
};

什么是深度优先和广度优先呢？
我们可以将上面的对象转换为一个图，如下所示：

深度优先

所谓深度优先就是按照root => left-1 => left-1-1 => left-1-1-1 => left-1-2 => right-1 => right-1-1 => right-1-2 => right-1-2-1的顺序遍历。从根节点的左边查找一直查找到叶子节点，再查找右边。

如图，按照1、2、3、4的路径查找。

利用递归思想遍历

我们首先能想到的就是利用递归来实现，如下：

function fnRecursive(node) {
    let result = [];
    for (let i in node) {
        i === "n" ? result.push(node[i]) : result = result.concat(fnRecursive(node[i]))
    }
    return result
}

因为采用了递归的关系，可能会对性能有一定的影响。还有另外一种利用栈先进后出的特性实现深度遍历。

利用栈的思想遍历

function fnStack(node) {
    let results = [],
        stacks = [];
    stacks.push(node);
    while (stacks.length) {
        let currentNode = stacks.pop();
        if (currentNode) {
            results.push(currentNode.n);
            for (let i = currentNode.child.length - 1; i >= 0; i--) {
                stacks.push(currentNode.child[i])
            }
        }
    }
    return results
}

每次按照图中右左的顺序依次压入栈中，先进栈的是整个右边节点，左边节点在进栈，将左边取出来，如果有child，继续入栈，那么左边的孩子节点就能先被获取到，从而实现深度遍历。

广度优先

所谓广度优先，如图，按照1、2、3从左到右一次执行，顺序：root => left-1 => right-1 => left-1-1 => … => right-1-2-1。

采用队列思想遍历

function fnQueue(node) {
    let results = [],
        queues = [];
    queues.push(node);
    while (queues.length) {
        let currentNode = queues.shift();
        if (currentNode) {
            results.push(currentNode.n);
            for (let i = 0; i <= currentNode.child.length; i++) {
                queues.push(currentNode.child[i])
            }
        }
    }
    return results
}

队列具有先进先出的性质，1、2、3中的孩子从左到右依次进队，按照顺序取出即可
如有错误，欢迎指出~~