LeetCode 103. Binary Tree Zigzag Level Order Traversal 二叉树Z字形层级遍历（Java）

题目：

Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).

解答：

解法一：堆栈

与 LeetCode 102 题相似，将层序遍历改为z字形，因为涉及到逆序的问题，且 102 题中也用到了队列的方法，所以首先想到可以通过栈来实现逆序

用两个堆栈，forwordStack 为顺序栈（即逆序进栈，顺序出栈），backStack 为逆序栈（即顺序出栈，逆序进栈），两个栈分别在相邻层之间交替使用。

代码实现如下：

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) {
            return res;
        }
        Stack<TreeNode> forwordStack = new Stack<>();
        Stack<TreeNode> backStack = new Stack<>();
        forwordStack.push(root);
        while(!forwordStack.isEmpty() || !backStack.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            TreeNode node = new TreeNode();
            while(!forwordStack.isEmpty()) {
                node = forwordStack.pop();
                list.add(node.val);
                if(node.left != null) {
                    backStack.push(node.left);
                }
                if(node.right != null) {
                    backStack.push(node.right);
                }
            }
            if(list != null) {
                res.add(list);
                list = new ArrayList<>();
            }
            while(!backStack.isEmpty()) {
                node = backStack.pop();
                list.add(node.val);
                if(node.right != null) {
                    forwordStack.push(node.right);
                }
                if(node.left != null) {
                    forwordStack.push(node.left);
                }
            }
            if(!list.isEmpty()) {
                res.add(list);
                list = new ArrayList<>();
            }
        }
        return res;
    }
}

提交结果为：

解法二：队列

这种解法与102题相同，唯一的不同是增加了 level 标识，用来记录当前遍历到了第几层，若 level % 2 == 1，说明当前为奇数层，需要逆序，则通过 Collections.reverse() 实现当前层节点的逆序

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int level = 0;
        while(!queue.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            int count = queue.size();
            for(int i=0; i<count; i++) {
                TreeNode node = queue.poll();
                list.add(node.val);
                if(node.left != null) {
                    queue.add(node.left);
                }
                if(node.right != null) {
                    queue.add(node.right);
                }
            }
            if(level % 2 == 1)
                Collections.reverse(list);
            level++;
            res.add(list);
        }
        return res;
    }
}

提交结果为：

解法三：递归

其中通过 level 记录层级数，并通过 LinkedList 的 addFirst() 方法实现逆序

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        levelRecursion(root, result, 0);
        return result;
    }
    private void levelRecursion(TreeNode node, List<List<Integer>> result,
            int level) {
        if (node == null) {
            return;
        }
        if (result.size() < level + 1) {// 说明还需要添加一行
            result.add(new LinkedList<Integer>());
        }
        if (level % 2 != 0) {
            ((LinkedList<Integer>) result.get(level)).addFirst(node.val);
        } else {
            result.get(level).add(node.val);
        }
        levelRecursion(node.left, result, level + 1);
        levelRecursion(node.right, result, level + 1);
    }
}