算法通关村 | 树的层次遍历

二叉树的层序遍历

LeetCode102 题目要求：给你一个二叉树，请你返回其按层序遍历得到的节点值。(即逐层地，从左到右访问所有节点)。

二叉树：[3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
返回其层序遍历结果：
 [
  [3],
  [9,20],
  [15,7]
]

我们再观察执行过程图，我们先将根节点放到队列中，然后不断遍历队列。

那如何判断某一层访问完了呢？简单，用一个变量size标记一下就行了，size表示某一层的元素个数，只要出队，就将size减1，减到0就说明该层元素访问完了。当size变成0之后，这时队列中剩余元素的个数恰好就是下一层元素的个数，因此重新将size标记为下一层的元素个数就可以继续处理新的一行了，例如在上面的序列中：

1.首先拿根节点3，其左/右子结点都不为空，就将其左右放入队列中，因此此时3已经出队了，剩余元素9和20恰好就是第二层的所有结点，此时size=2。
2.继续，将9从队列中拿走，size--变成1，并将其子孩子8和13入队。之后再将20 出队，并将其子孩子15和7入队，此时再次size--，变成9了。当size=0，说明当前层已经处理完了，此时队列有四个元素，而且恰好就是下一层的元素个数。

最后，我们把每层遍历到的节点都放入到一个结果集中，将其返回就可以了：

按层打印经典版代码：

public List<List<Integer>> level102Order(TreeNode root) {
    if(root==null) {
        return new ArrayList<List<Integer>>();
    }

    List<List<Integer>> res = new ArrayList<List<Integer>>();
    LinkedList<TreeNode> queue = new LinkedList<TreeNode>();
    //将根节点放入队列中，然后不断遍历队列
    queue.add(root);
    while(queue.size()>0) {
        //获取当前队列的长度，也就是当前这一层的元素个数
        int size = queue.size();
        ArrayList<Integer> tmp = new ArrayList<Integer>();
        //将队列中的元素都拿出来(也就是获取这一层的节点)，放到临时list中
        //如果节点的左/右子树不为空，也放入队列中
        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);
            }
        }
        //此时的tmp就是当前层的全部元素，用List类型的tmp保存，加入最终结果集中
        res.add(tmp);
    }
    return res;
}

叉树的锯齿形层序遍历

LeetCode103 题，要求是：给定一个二叉树，返回其节点值的锯齿形层序遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如：给定二叉树 [3,9,20,null,null,15,7]

返回结果是：

[
  [3],
  [20,9],
  [15,7]
]

当是奇数行就从左至右，偶数行就从右至左

• 如果从左至右，我们每次将被遍历到的元素插入至双端队列的末尾。

• 从右至左，我们每次将被遍历到的元素插入至双端队列的头部。

public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
    List<List<Integer>> ans = new LinkedList<List<Integer>>();
    if (root == null) {
        return ans;
    }
    Queue<TreeNode> queue = new LinkedList<TreeNode>();
    queue.offer(root);
    boolean isOrderLeft = true;
    while (!queue.isEmpty()) {
        Deque<Integer> levelList = new LinkedList<Integer>();
        int size = queue.size();
        for (int i = 0; i < size; ++i) {
            TreeNode curNode = queue.poll();
            if (isOrderLeft) {
                levelList.offerLast(curNode.val);
            } else {
                levelList.offerFirst(curNode.val);
            }
            if (curNode.left != null) {
                queue.offer(curNode.left);
            }
            if (curNode.right != null) {
                queue.offer(curNode.right);
            }
        }
        ans.add(new LinkedList<Integer>(levelList));
        isOrderLeft = !isOrderLeft;
    }
    return ans;
}

在每个树行中找最大值

LeetCode 515题目要求：给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

这里其实就是在得到一层之后使用一个变量来记录当前得到的最大值：

public List<Integer> largestValues(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    Deque<TreeNode> deque = new ArrayDeque<>();

    if (root != null) {
        deque.addLast(root);
    }

    while (!deque.isEmpty()) {
        int size = deque.size();
        int levelMaxNum = Integer.MIN_VALUE;
        for (int i = 0; i < size; i++) {
            TreeNode node = deque.poll();
            levelMaxNum = Math.max(node.val,levelMaxNum);
            if (node.left != null) deque.addLast(node.left);
            if (node.right != null) deque.addLast(node.right);
        }
        res.add(levelMaxNum);
    }
    return res;
}