算法通关村—广度优先遍历原来如此简单

层序遍历

二叉树的层序遍历

使用队列进行遍历二叉树

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        if (root == null) {
            return new ArrayList<List<Integer>>();
        }
        // 结果集合
        List<List<Integer>> res = new LinkedList<>();
        // 队列集合
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        // 这个 queue.siez() 是我们每一行有元素的个数
        while (queue.size() > 0) {
            int size = queue.size();
            ArrayList<Integer> tmp = new ArrayList<Integer>();
            // 把这一样的所有的元素都拿出来，放到对应的集合之中
            for (int i = 0; i < size; i++) {
                TreeNode t = queue.remove();
                tmp.add(t.val);
                // 这里的顺序不要写反，自左向右
                if (t.left != null) {
                    queue.add(t.left);
                }
                if (t.right != null) {
                    queue.add(t.right);
                }
            }
            res.add(tmp);
        }
        // 返回集合
        return res;
    }
}

PS 深度优先，这段代码非常重要，一定要好好理解！

题目 102. 二叉树的层序遍历 ，上面代码就苦于解决这个问题

层序遍历-自底向上

LeetCode 107

其实就层序遍历的变形

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> levelOrder = new LinkedList<List<Integer>>();
        if (root == null) {
            return levelOrder;
        }
        // 创建一个队列
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (queue.size() > 0) {
            int size = queue.size();
            List<Integer> temp = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode t = queue.remove();
                temp.add(t.val);
                // 不需要更换这个顺序，如果更换这个顺序那么么结果就变成了
                // [[7,15],[20,9],[3]] 左右的顺序就变了
                if (t.left != null) {
                    queue.add(t.left);
                }
                if (t.right != null) {
                    queue.add(t.right);
                }
            }
            levelOrder.add(0, temp);
        }
        return levelOrder;
    }
}

二叉树的锯齿形层序遍历

LeetCode103

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        // 创建返回的结果集合
        List<List<Integer>> levelOrder = new LinkedList<List<Integer>>();
        if (root == null) {
            return levelOrder;
        }
        // Flag to indicate the traversal direction
        boolean isLeftToRight = true;
        // 创建队列
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (queue.size() > 0) {
            ArrayList<Integer> temp = new ArrayList<>();
            int size = queue.size();
            // 循环遍历
            for (int i = 0, j = 1; i < size; i++, j++) {
                TreeNode t = queue.remove();
                if (isLeftToRight) {
                    // 正向添加
                    temp.add(t.val);
                } else {
                    // 反向添加
                    temp.add(0, t.val);
                }
                if (t.left != null) {
                    queue.add(t.left);
                }
                if (t.right != null) {
                    queue.add(t.right);
                }
            }
            levelOrder.add(temp);
            isLeftToRight = !isLeftToRight;
        }
        return levelOrder;
    }
}

N 叉树的层序遍历

N 叉树的层序遍历

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> value = new ArrayList<>();
        Deque<Node> q = new ArrayDeque<>();
        if (root != null)
            q.addLast(root);
        while (!q.isEmpty()) {
            Deque<Node> next = new ArrayDeque<>();
            List<Integer> nd = new ArrayList<>();
            while (!q.isEmpty()) {
                // 取出 q 
                Node cur = q.pollFirst();
                nd.add(cur.val);
                for (Node chd : cur.children) {
                    if (chd != null) {
                        next.add(chd);
                    }
                }
            }
            // 这个 next 需要赋值给 q
            q = next;
            value.add(nd);
        }
        return value;
    }
}

每层处理元素

可以进行，取出每行的最大值 （LeetCode515），平均值（LeetCode637） …
都是第一个层序遍历的变形

最底层最左边

LCR 045. 找树左下角的值

从右向左添加元素，只要是最后一个就是底层最左边的元素

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        if (root.left == null && root.right == null) {
            return root.val;
        }
        // 创建队列
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        TreeNode t = new TreeNode(-100);
        while (!queue.isEmpty()) {
            t = queue.remove();
            
            if (t.right != null) {
                queue.add(t.right);
            }

            if (t.left != null) {
                queue.add(t.left);
            }
        }
        return t.val;
    }
}