数据结构学习篇-深度/广度优先遍历

介绍

• 深度优先

遍历时，如果有子节点，优先读取子节点，子节点完成后再读取同级节点

• 广度优先

遍历时，优先读取同级节点，再从头开始读取下一级节点

实现思路

• 深度优先可用递归方式实现，定义一个函数，参数为一个节点，读取该节点，如果改节点有子节点，遍历使用该函数读取该元素的子节点，形成递归
• 深度优先也可用栈来实现，定义一个栈结构，将根节点放入，开始循环，如果栈结构不为空时则执行读取栈顶元素，读取完毕后移除该元素，如果该元素有子节点，将所有子节点反转后依次入栈

代码实现

0. 数据格式

const data = {
    val: 1,
    children: [
        {
            val: 2,
            children: [
                {
                    val: 3,
                    children: null,
                },
                {
                    val: 4,
                    children: null,
                },
            ],
        },
        {
            val: 5,
            children: null,
        },
    ],
};

1. 深度优先（递归实现）

function DFSbyRecursion(data) {
    // 存储读取到的每一项数据
    let result = [];
    // 执行递归的函数
    deal(data);
    // 定义递归的函数
    function deal(data) {
        if (!data) return false;
        if (data.val) {
            // 存储读取到的数据
            result.push(data.val);
            // 如果有子节点
            if (data.children && data.children.length > 0) {
                // 遍历递归执行读取子节点
                data.children.forEach(item => {
                    deal(item);
                })
            }
        }
    }
    return result.join(',');
}

2. 广度优先（队列实现）

function BFSbyQueue(data) {
    // 越界判断
    if (!data) return false;
    // 根节点入队
    let list = [data];
    // 存储数据
    let result = [];
    while (list.length) {
        // 出队
        const item = list.shift();
        // 读取数据
        result.push(item.val);
        // 如果有子节点 
        if (item.children && item.children.length > 0) {
            // 子节点依次入队
            list = list.concat(item.children)
        }
    }
    return result.join(',');
}

3. 深度优先（栈实现）

function DFSbyStack(data) {
    // 越界判断
    if (!data) return false;
    // 存储结果
    let result = [];
    // 将根节点入栈
    let list = [data];
    while (list.length > 0) {
        // 取出栈顶节点
        const item = list.pop();
        // 读取
        result.push(item.val);
        // 判断子节点
        if (item.children && item.children.length > 0) {
            // 将子节点反转后入栈
            list = list.concat(item.children.reverse());
        }
    }
    return result.join(',');
}