每日一道Leetcode——二叉树的锯齿形层序遍历

最新推荐文章于 2023-12-15 14:06:43 发布

LLLittleWhite

最新推荐文章于 2023-12-15 14:06:43 发布

阅读量170

点赞数

文章标签： leetcode 二叉树广度优先搜索

本文链接：https://blog.csdn.net/weixin_41945051/article/details/111505714

版权

题目：
在这里插入图片描述
我的解法：广度优先搜索
思路：先按照层序遍历将每一层节点值存入一个list，然后将奇数层的list进行反转，最后存入答案list

/**
 * 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>> ans = new ArrayList<List<Integer>>();
        if(root==null){
            return ans;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int num = 0;
        while(queue.size()!=0){
            int n = queue.size();
            List<Integer> list = new ArrayList<Integer>();
            for(int i=0; i<n; i++){
                TreeNode t = queue.poll();
                list.add(t.val);
                if(t.left!=null){
                    queue.offer(t.left);
                }
                if(t.right!=null){
                    queue.offer(t.right);
                }
            }
            if(num%2==0){
                ans.add(list);
            }else{
                for(int j=0; j<list.size()/2; j++){
                    int temp = list.get(j);
                    list.set(j, list.get(list.size()-1-j));
                    list.set(list.size()-1-j, temp);
                }
                ans.add(list);    
            }
            num++;
        }
        return ans;
    }
}

在这里插入图片描述
官方题解：

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ans = new LinkedList<List<Integer>>();
        if (root == null) {
            return ans;
        }

        Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();
        nodeQueue.offer(root);
        boolean isOrderLeft = true;

        while (!nodeQueue.isEmpty()) {
            Deque<Integer> levelList = new LinkedList<Integer>();
            int size = nodeQueue.size();
            for (int i = 0; i < size; ++i) {
                TreeNode curNode = nodeQueue.poll();
                if (isOrderLeft) {
                    levelList.offerLast(curNode.val);
                } else {
                    levelList.offerFirst(curNode.val);
                }
                if (curNode.left != null) {
                    nodeQueue.offer(curNode.left);
                }
                if (curNode.right != null) {
                    nodeQueue.offer(curNode.right);
                }
            }
            ans.add(new LinkedList<Integer>(levelList));
            isOrderLeft = !isOrderLeft;
        }

        return ans;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/solution/er-cha-shu-de-ju-chi-xing-ceng-xu-bian-l-qsun/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。