剑指 Offer 32 - I. 从上到下打印二叉树
题目描述：
从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。、
题目来源于LeetCode：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof/
解题思路：
- 题目要求将树类型的数据分层从左往右打印，输出的形式是
int[]数组类型，我们可以借助队列，采用中序遍历的方法先将树节点保存到队列中，然后将队列中结点对应的值存放到List类型的数组中，然后再转换到数组中。
/**
* 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];
//借助队列将树节点值存入List<Integer>中
List<Integer> arr = new ArrayList<Integer>();
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode cur = queue.poll();
arr.add(cur.val);
if (cur.left != null) {
queue.offer(cur.left);
}
if (cur.right != null) {
queue.offer(cur.right);
}
}
//将List<Integer>类型的数据提取出来存入int[]中
int[] ans = new int[arr.size()];
for (int i = 0; i < arr.size(); i++) {
ans[i] = arr.get(i);
}
return ans;
}
}
剑指 Offer 32 - II. 从上到下打印二叉树 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) {
List<List<Integer>> arr = new ArrayList<List<Integer>>();
if (root == null) return arr;
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
while (!queue.isEmpty()) {
List<Integer> ans = new ArrayList<Integer>();
int len = queue.size();
for (int i = 0; i < len; i++) {
TreeNode cur = queue.poll();
ans.add(cur.val);
if (cur.left != null) {
queue.offer(cur.left);
}
if (cur.right != null) {
queue.offer(cur.right);
}
}
arr.add(ans);
}
return arr;
}
}
剑指 Offer 32 - III. 从上到下打印二叉树 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) {
List<List<Integer>> arr = new LinkedList<List<Integer>>();
if (root == null) return arr;
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
boolean leftToRight = true;
while (!queue.isEmpty()) {
Deque<Integer> deque = new LinkedList<Integer>();
int len = queue.size();
for (int i = 0; i < len; i++) {
TreeNode node = queue.poll();
//针对二叉树的奇偶层做相应处理
//奇数层从队尾进入双端队列
//偶数层从对头进入双端队列
if (leftToRight) {
deque.offerLast(node.val);
} else {
deque.offerFirst(node.val);
}
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
arr.add(new LinkedList<Integer>(deque));
leftToRight = !leftToRight;
}
return arr;
}
}