103. Binary Tree Zigzag Level Order Traversal-优快云博客

本文链接：https://blog.youkuaiyun.com/brynjiang/article/details/103380101

本文介绍了一种二叉树的特殊遍历方式——锯齿形层序遍历，通过两种方法实现：一种是逢偶数层反转列表，另一种是使用两个栈交替进行节点存储和遍历，以达到从左到右再从右到左的交替遍历效果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目

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).

我的想法

层级遍历二叉树，逢偶倒转list

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) {
            return res;
        }
        
        Deque<TreeNode> queue = new LinkedList<>();
        queue.addLast(root);
        boolean reverse = false;
        while(!queue.isEmpty()) {
            int size = queue.size();
            ArrayList<Integer> list = new ArrayList<>();
            for(int i = 0; i < size; i++) {
                TreeNode node = queue.pollFirst();
                list.add(node.val);
                if(node.left != null) {
                    queue.addLast(node.left);
                }
                if(node.right != null) {
                    queue.addLast(node.right);
                }
            }
            if(reverse) {
                int left = 0, right = list.size() - 1;
                while(left < right) {
                    int temp = list.get(left);
                    list.set(left, list.get(right));
                    list.set(right, temp);
                    left++;
                    right--;
                }
            }
            res.add(list);
            reverse = !reverse;
        }
        return res;
    }
}

解答

jiuzhang solution
用两个stack来完成反向

public class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();

        if (root == null) {
            return result;
        }

        Stack<TreeNode> currLevel = new Stack<TreeNode>();
        Stack<TreeNode> nextLevel = new Stack<TreeNode>();
        Stack<TreeNode> tmp;
        
        currLevel.push(root);
        boolean normalOrder = true;

        while (!currLevel.isEmpty()) {
            ArrayList<Integer> currLevelResult = new ArrayList<Integer>();

            while (!currLevel.isEmpty()) {
                TreeNode node = currLevel.pop();
                currLevelResult.add(node.val);

                if (normalOrder) {
                    if (node.left != null) {
                        nextLevel.push(node.left);
                    }
                    if (node.right != null) {
                        nextLevel.push(node.right);
                    }
                } else {
                    if (node.right != null) {
                        nextLevel.push(node.right);
                    }
                    if (node.left != null) {
                        nextLevel.push(node.left);
                    }
                }
            }

            result.add(currLevelResult);
            tmp = currLevel;
            currLevel = nextLevel;
            nextLevel = tmp;
            normalOrder = !normalOrder;
        }

        return result;

    }
}