从上到下打印二叉树（层序遍历）

剑指 Offer 32 - I

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] levelOrder(TreeNode root) {
        // 用集合（ArrayList集合，有序的）去添加层序遍历的结果，最后将集合再转为数组
        // 为什么不直接用int[]接收？节点数目不确定，如果你确定一个值，后面全0了啊，所以很自然的想到集合，动态分配
        List<Integer> ans = new ArrayList<>();
        // 先来判空，root如果为null的话，直接return一个空数组
        if (root==null) {
            return new int[0];
        }
        // 初始化队列
        Queue<TreeNode> q = new LinkedList<>();
        // 将root加入队列
        q.offer(root);
        // 如果不为空，就一直循环下去
        while (!q.isEmpty()) {
            // 利用队列的特性，先进先出，将头部依次弹出
            TreeNode cur = q.poll();
            // 把弹出来的这个节点先加入集合
            ans.add(cur.val);
            // 当然是先左后右了，顺序结构语句，所以先判断左节点是否为空
            if (cur.left != null) {
                q.offer(cur.left);
            }
            // 再判断右节点是否为空
            if (cur.right != null) {
                q.offer(cur.right);
            }
        }
        // 题目要求返回整型数组，那就再遍历一次吧
        int[] ints = new int[ans.size()];
        for (int i = 0; i < ans.size(); i++) {
            ints[i] = ans.get(i);
        }
        // 最终返回
        return ints;
    }
}

剑指 Offer 32 - II

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
    	// 老规矩，根据返回类型new一个对象，这里返回的是List集合，不用再处理什么了，直接new吧
        List<List<Integer>> lists = new ArrayList<>();
        // 判断空
        if (root == null) {
        	// 比之前返回数组好一点，直接返回lists即可
            return lists;
        }
        // 初始化队列
        Queue<TreeNode> queue = new LinkedList<>();
        // 将root加入队列，队列此时只有一个元素
        queue.offer(root);
        // 继续循环吧
        while (!queue.isEmpty()) {
        	// 这个题，要按照行再存放在一个集合中，那么就new一个集合吧
            List<Integer> temp = new ArrayList<>();
            // 此时就不能盲目的添加了，要有条件的去判断，用for循环判断一层有多少节点
            // 第一次循环，只有root，循环一次遍退出，这时往队列加了两个元素（先认为是满二叉树）
            // 你想想，第二次，进入for循环的时候，之前可是往队列里加了两个元素，然后第三次又加了四个元素，这个for循环是关键
            for (int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                temp.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            // 一层节点添加完后，再加到lists集合中（lists便是那个集合套集合的对象）
            lists.add(temp);
        }
        // 最终返回lists
        return lists;
    }
}

剑指 Offer 32 - III

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
    
    	// start
        List<List<Integer>> lists = new ArrayList<>();
        if (root == null) {
            return lists;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        // end
        
        while (!queue.isEmpty()) {
        	// 选好合适的数据结构
        	// 来个双端队列，来处理奇偶层——左到右遍历，右到左遍历
            LinkedList<Integer> temp = new LinkedList<>();
            for (int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                if (lists.size()%2==0) {
                	// 如果是偶数层，那么就addLast，在链表头部添加
                    temp.addLast(node.val);
                } else if(lists.size()%2==1) {
                	// 如果是奇数层，那么就addLast，在链表尾部添加
                    temp.addFirst(node.val);
                }
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            lists.add(temp);
        }
        return lists;
    }
}

剑指 Offer 55 - I

不追求花式解题，只要能记住，就是王道！

深度会想到什么？

我想到是一层一层的

一层一层的又想到什么？

想到层序遍历通过for循环可以控制行输出

所以模板就打通了

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
    	// 用count记录一下深度吧，应该用depth吧，算了，代码已经写好了，不改了，无伤大雅
        int count = 0;
        // 先来判空，root如果为null的话，那深度就是0了
        if (root==null) {
            return count;
        }
        // 初始化队列
        Queue<TreeNode> q = new LinkedList<>();
        // 将root加入队列
        q.offer(root);
        // 如果不为空，就一直循环下去
        while (!q.isEmpty()) {
            // 判断树深，想一想，是不是得一行完了就记数（+1），一行一行的操作，那必须for循环控制一下
            for (int i = q.size(); i > 0; i--) {
                TreeNode cur = q.poll();
                if (cur.left != null) {
                    q.offer(cur.left);
                }
                if (cur.right != null) {
                    q.offer(cur.right);
                }
            }
            // 每层搞完以后+1一下，表示树深+1
            count++;
        }
        return count;
    }
}