Binary Tree Zigzag Level Order Traversal

Question

  1. Given a binary tree, return the zigzag level order traversal of its nodes' values.
  2. (ie, from left to right, then right to left for the next level and alternate between).
  4. Example
  5. Given binary tree {3,9,20,#,#,15,7},
  7.     3
  8.    / \
  9.   9  20
  10.     /  \
  11.    15   7
  14. return its zigzag level order traversal as:
  16. [
  17.   [3],
  18.   [20,9],
  19.   [15,7]
  20. ]

题解1 - 队列

二叉树的广度优先遍历使用队列非常容易实现，这道题要求的是蛇形遍历，我们可以发现奇数行的遍历仍然可以按照广度优先遍历的方式实现，而对于偶数行，只要翻转一下就好了。

Java

  1. /**
  2.  * Definition of TreeNode:
  3.  * public class TreeNode {
  4.  *     public int val;
  5.  *     public TreeNode left, right;
  6.  *     public TreeNode(int val) {
  7.  *         this.val = val;
  8.  *         this.left = this.right = null;
  9.  *     }
  10.  * }
  11.  */
  13. public class Solution {
  14.     /**
  15.      * @param root: The root of binary tree.
  16.      * @return: A list of lists of integer include
  17.      *          the zigzag level order traversal of its nodes' values
  18.      */
  19.     public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
  20.         ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
  21.         if (root == null) return result;
  23.         boolean odd = true;
  24.         Queue<TreeNode> q = new LinkedList<TreeNode>();
  25.         q.offer(root);
  26.         while (!q.isEmpty()) {
  27.             // level traversal
  28.             int qLen = q.size();
  29.             ArrayList<Integer> level = new ArrayList<Integer>();
  30.             for (int i = 0; i < qLen; i++) {
  31.                 TreeNode node = q.poll();
  32.                 level.add(node.val);
  33.                 if (node.left != null) q.offer(node.left);
  34.                 if (node.right != null) q.offer(node.right);
  35.             }
  36.             // add level order reverse for even
  37.             if (odd) {
  38.                 result.add(level);
  39.             } else {
  40.                 Collections.reverse(level);
  41.                 result.add(level);
  42.             }
  43.             // flip odd and even
  44.             odd = !odd;
  45.         }
  47.         return result;
  48.     }
  49. }

源码分析

区分奇数偶数行使用额外变量。

复杂度分析

需要 reverse 的节点数目近似为 n/2, 故时间复杂度 O(n). 最下层节点数目最多 n/2, 故reverse 操作的空间复杂度可近似为 O(n/2).

总的时间复杂度为 O(n), 空间复杂度也为 O(n).

Reference