LeetCode-剑指Offer-32-|||-从上到下打印二叉树 |||

---

题意描述：

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

---

示例：

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

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

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

---

解题思路：

Alice: 怎么反转一个 ArrayList ?
Bob： 不用等到 ArrayList 对象里面都有元素再去反转，可以直接 反着往里慢填充元素呀。
Alice: add(index, element) 这个方法吗 ？
Bob: 对，然后什么时候反向填充就用 rowIndex % 2 == 0就好了。
Alice: 或者用 index != -1来判断，然后每行结束后 index *= -1
Bob: 对的，交替出现的正负和奇偶 都是一样的。
Alice: 对，就是 反转 ArrayList 可能会有更好的方法吧。

---

代码：

Python ： 列表当成队列 + BFS + 列表切片反转数组

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if root == None:
            return []
        else:

            ret = []
            nextLineNodes = [root]
            rowIndex = 0

            while len(nextLineNodes) != 0:

                nextLineValues = []
                helper = []

                while len(nextLineNodes) != 0:

                    node = nextLineNodes.pop(0)
                    if node:
                        nextLineValues.append(node.val)
                        if node.left:
                            helper.append(node.left)
                        if node.right:
                            helper.append(node.right)

                
                if rowIndex % 2 == 0:
                    ret.append(nextLineValues)
                else:
                    ret.append(nextLineValues[::-1])
                rowIndex += 1
                nextLineNodes = helper
                
            return ret

Java : rowIndex + ArrayList.add(index, element) 实现反向填充数组，效率好像很慢

/**
 * 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) {

        if(root == null){
            return new ArrayList<List<Integer>>();
        }else{

            List<List<Integer>> ret = new ArrayList<List<Integer>>();
            Queue<TreeNode> nextLineNodes = new LinkedList<TreeNode>();
            nextLineNodes.offer(root);
            int rowIndex = 0;

            while(nextLineNodes.isEmpty()  == false){

                List<Integer> nextLineValues = new ArrayList<Integer>();
                Queue<TreeNode> tmp = new LinkedList<TreeNode>();

                while(nextLineNodes.isEmpty() == false){
                    TreeNode node = nextLineNodes.poll();
                    if(node != null){
                        if(rowIndex % 2 == 0){
                            nextLineValues.add(node.val);
                        }else{
                            nextLineValues.add(0, node.val);   // 反向填充
                        }
                        if(node.left != null){
                            tmp.offer(node.left);
                        }
                        if(node.right != null){
                            tmp.offer(node.right);
                        }
                    }
                }
                nextLineNodes = tmp;
                ret.add(nextLineValues);
                rowIndex += 1;
            }
            return ret;
        }
    }
}

---

易错点：

• 一些测试用例：

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

• 答案：

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

---

总结：

---