LeetCode（102 & 103）：二叉树的层次遍历 & 锯齿形遍历 Binary Tree Level Order Traversal（Java）

2019.8.3 #程序员笔试必备# LeetCode 从零单刷个人笔记整理（持续更新）

这两题都是剑指Offer原题，笔记可见：

#数据结构与算法学习笔记#剑指Offer58：把二叉树打印成多行（Java、C/C++）

#数据结构与算法学习笔记#剑指Offer57：按之字形顺序打印二叉树（Java、C/C++）

层序遍历二叉树没什么好说的，一个简单的BFS。锯齿形/之字形打印也只需要在层序遍历的基础上按行区别输出顺序即可。

---

传送门：二叉树的层次遍历

Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

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

    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：
[
  [3],
  [9,20],
  [15,7]
]

传送门：二叉树的锯齿形层次遍历

Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).

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

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

    3
   / \
  9  20
    /  \
   15   7
返回锯齿形层次遍历如下：
[
  [3],
  [20,9],
  [15,7]
]

---

import java.util.LinkedList;
import java.util.List;

/**
 * Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).
 * 给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。
 */

public class BinaryTreeLevelOrderTraversal {

    public class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
        }
    }

    //层次遍历
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new LinkedList<>();
        LinkedList<TreeNode> list = new LinkedList<>();
        if (root != null) {
            list.add(root);
        }
        while (!list.isEmpty()) {
            int size = list.size();
            LinkedList<Integer> rownums = new LinkedList<>();
            for (int i = 0; i < size; i++) {
                TreeNode p = list.pollFirst();
                rownums.add(p.val);
                if (p.left != null) {
                    list.add(p.left);
                }
                if (p.right != null) {
                    list.add(p.right);
                }
            }
            result.add(rownums);
        }
        return result;
    }

    //锯齿遍历/Z字形遍历（分层打印）
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new LinkedList<>();
        LinkedList<TreeNode> list = new LinkedList<>();
        if (root != null) {
            list.add(root);
        }
        boolean rowflag = true;
        while (!list.isEmpty()) {
            int size = list.size();
            LinkedList<Integer> rownums = new LinkedList<>();
            for (int i = 0; i < size; i++) {
                TreeNode p = list.pollFirst();
                if (rowflag) {
                    rownums.add(p.val);
                } else {
                    rownums.addFirst(p.val);
                }
                if (p.left != null) {
                    list.add(p.left);
                }
                if (p.right != null) {
                    list.add(p.right);
                }
            }
            rowflag = !rowflag;
            result.add(rownums);
        }
        return result;
    }

}

---

#Coding一小时，Copying一秒钟。留个言点个赞呗，谢谢你#