面试题32 - I、ll、lll 从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回：

[3,9,20,15,7]

 

提示：

    节点总数 <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

第一题直接BFS

/**
 * 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) {
        if(root == null){
            return new int [0];
        }
        Queue <TreeNode> que = new LinkedList<>();
        que.add(root);
        List<Integer> list = new ArrayList<>();
        while(que.size() != 0){
            TreeNode temp = que.poll();
            if(temp.left != null){
               que.add(temp.left);    
            }
            if(temp.right != null){
               que.add(temp.right);    
            }
            list.add(temp.val);
        }
        int [] res = new int [list.size()];
        for(int i = 0; i < list.size();i++){
            res[i] = list.get(i);
        }
        return res;
    }
}

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

 

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

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

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

 

提示：

    节点总数 <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

第二题要分层打印，就用双队列，轮流操作。

/**
 * 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) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        Queue<TreeNode> que1 = new LinkedList<>();
        Queue<TreeNode> que2 = new LinkedList<>();
        int n = 1;
        que1.add(root);
        while(que1.size() != 0 || que2.size() != 0){
            if(n % 2 == 1){
               List<Integer> list = new ArrayList<>();
               while(que1.size() != 0){
                   TreeNode temp = que1.poll();
                   list.add(temp.val);
                   if(temp.left != null){
                       que2.add(temp.left);
                   }
                   if(temp.right != null){
                       que2.add(temp.right);
                   }
               }
               res.add(list);
            }
            if(n % 2 == 0){
                List<Integer> list = new ArrayList<>();
               while(que2.size() != 0){
                   TreeNode temp = que2.poll();
                   list.add(temp.val);
                   if(temp.left != null){
                       que1.add(temp.left);
                   }
                   if(temp.right != null){
                       que1.add(temp.right);
                   }
               }
               res.add(list);
            }
            n++;
        }
        return res;
    }
}

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

 

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

    3
   / \
  9  20
    /  \
   15   7

返回其层次遍历结果：

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

 

提示：

    节点总数 <= 1000

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

第三题是Z型打印，可以使用双栈，单数行从右往左入栈，双数行从左往又入栈，这样就能做到让单数行正着跑，双数行反着跑了

/**
 * 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) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null){
            return res;
        }
        LinkedList<TreeNode> stack1 = new LinkedList<>();
        LinkedList<TreeNode> stack2 = new LinkedList<>();
        int n = 1;
        stack1.push(root);
        while(stack1.size() != 0 || stack2.size() != 0){
            if(n % 2 == 1){
               List<Integer> list = new ArrayList<>();
               while(stack1.size() != 0){
                   TreeNode temp = stack1.pop();
                   list.add(temp.val);
                   if(temp.left != null){
                       stack2.push(temp.left);
                   }
                   if(temp.right != null){
                       stack2.push(temp.right);
                   }
               }
               res.add(list);
            }
            if(n % 2 == 0){
               List<Integer> list = new ArrayList<>();
               while(stack2.size() != 0){
                   TreeNode temp = stack2.pop();
                   list.add(temp.val);
                   if(temp.right != null){
                       stack1.push(temp.right);
                   }
                   if(temp.left != null){
                       stack1.push(temp.left);
                   }
               }
               res.add(list);
            }
            n++;
        }
        return res;
    }
}