【剑指Offer】22、从上往下打印二叉树

题目描述

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

题解：LinkedList模拟队列

 1 public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
 2       ArrayList<Integer> list = new ArrayList<>();
 3         if (root == null) {
 4             return list;
 5         }
 6         LinkedList<TreeNode> queue = new LinkedList<>();
 7         queue.add(root);
 8         while (queue.size() != 0) {
 9             //取出一个节点
10             TreeNode treeNode = queue.poll();
11             //记录出队节点的值
12             list.add(treeNode.val);
13             if (treeNode.left != null) {
14                 queue.offer(treeNode.left);
15             }
16             if (treeNode.right != null) {
17                 queue.offer(treeNode.right);
18             }
19         }
20         return list;
21     }

初始化二叉树：

 1 public static class TreeNode {
 2         int val = 0;
 3         TreeNode left = null;
 4         TreeNode right = null;
 5         public TreeNode(int val) {
 6             this.val = val;
 7         }
 8     }
 9 public static TreeNode createBinTree(int[] array) {
10         nodeList=new LinkedList<TreeNode>();
11         // 将一个数组的值依次转换为TreeNode节点
12         for (int nodeIndex = 0; nodeIndex < array.length; nodeIndex++) {
13             nodeList.add(new TreeNode(array[nodeIndex]));
14         }
15         // 对前lastParentIndex-1个父节点按照父节点与孩子节点的数字关系建立二叉树
16         for (int parentIndex = 0; parentIndex < array.length / 2 - 1; parentIndex++) {
17             // 左孩子
18             nodeList.get(parentIndex).left = nodeList
19                     .get(parentIndex * 2 + 1);
20             // 右孩子
21             nodeList.get(parentIndex).right = nodeList
22                     .get(parentIndex * 2 + 2);
23         }
24         // 最后一个父节点:因为最后一个父节点可能没有右孩子，所以单独拿出来处理
25         int lastParentIndex = array.length / 2 - 1;
26         // 左孩子
27         nodeList.get(lastParentIndex).left = nodeList
28                 .get(lastParentIndex * 2 + 1);
29         // 右孩子,如果数组的长度为奇数才建立右孩子
30         if (array.length % 2 == 1) {
31             nodeList.get(lastParentIndex).right = nodeList
32                     .get(lastParentIndex * 2 + 2);
33         }
34         return nodeList.get(0);
35     }

测试：

1 public static void main(String[] args) {
2         int[] array = {4,7,2,1,5,3,8,6};
3         TreeNode rootNode = createBinTree(array);
4         ArrayList<Integer> arrayList = PrintFromTopToBottom(rootNode);
5         for (Integer integer : arrayList) {
6             System.out.print(integer+" ");
7         }
8     }输出：4 7 2 1 5 3 8 6

原文地址：https://www.cnblogs.com/Blog-cpc/p/12347267.html