Leetcode 103. 二叉树的锯齿形层次遍历

题目

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

解答

解法一：递归

前一道题目 Leetcode 102. 二叉树的层次遍历 的变种题。

递归方式只需要在原来的基础上增加一个奇偶层判断即可。

二叉树的层次遍历 博客地址：二叉树的层次遍历

代码

/**
 * 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>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        levelOrder(root, 0, res);
        return res;
    }
    
    private void levelOrder(TreeNode node, int level, List<List<Integer>> res) {
        if(node == null) return;
        
        if(level == res.size()) {
            res.add(new LinkedList<>());
        }
        
        if(level % 2 == 0) {
            res.get(level).add(node.val);
        } else {
            res.get(level).add(0, node.val);
        }
        
        levelOrder(node.left, level + 1, res);
        levelOrder(node.right, level + 1, res);
    }
}

结果

解法二：队列迭代

同理，在 Leetcode 102. 二叉树的层次遍历 基础上增加一个奇偶层判断。

如果是偶数层，按照遍历顺序正序添加进集合 cur 。

如果是奇数层，按照遍历顺序倒序序添加进集合 cur 。

代码

/**
 * 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>> zigzagLevelOrder(TreeNode root) {
        if(root == null) return new ArrayList<>();
        
        List<List<Integer>> res = new ArrayList<>();
        LinkedList<TreeNode> deque = new LinkedList<>();
        deque.offer(root);
        boolean leftStart = true;
        while(!deque.isEmpty()) {
            int size = deque.size();
            List<Integer> cur = new LinkedList<>();
            while(size -- > 0) {
                TreeNode node = deque.poll();
                if(node.left != null) {
                    deque.offer(node.left);
                }
                
                if(node.right != null) {
                    deque.offer(node.right);
                }
                
                if(leftStart) {
                    cur.add(node.val); 
                } else {
                    cur.add(0, node.val); 
                }
            }
            
            res.add(cur);
            leftStart = !leftStart;
        }
        
        return res;
    }
}

结果