[LeetCode] 103. Binary Tree Zigzag Level Order Traversal

题：https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/description/

题目

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

For example:

Given binary tree [3,9,20,null,null,15,7],
    3
   / \
  9  20
    /  \
   15   7
return its zigzag level order traversal as:
[
  [3],
  [20,9],
  [15,7]
]

思路

题目大意

给定一个二叉树，对树进行层遍历，但层遍历方向会变化，开始从左到右，然后从右到左，不断变化。

解题思路

方法一 树的层遍历 ，层的遍历结果翻转

对树进行层遍历，将特定层的遍历结果进行翻转操作。

方法二 stack 实现上层先遍历的结点的子结点下层后遍历

stack 实现上层先遍历的结点的子结点下层后遍历，从而 产生 本层从左到右遍历 下层从右到左遍历。

code

方法一 树的层遍历 ，层的遍历结果翻转

/**
 * 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<>();
        List<TreeNode> lst = new LinkedList<>();
        if(root==null) return res;
        int ilayer = 1;
        boolean isFromLeft;
        lst.add(root);
        while (!lst.isEmpty()){
            List<Integer> eleres = new ArrayList<>();
            int layerlen =  lst.size();
            for(int i = 0 ;i <layerlen ; i++){
                TreeNode tnode =  lst.get(0);
                lst.remove(0);
                eleres.add(tnode.val);
                if(tnode.left != null)   lst.add(tnode.left);
                if(tnode.right !=null) lst.add(tnode.right);   
            }
       
            if(ilayer%2==1){
                isFromLeft = true;
            }
            else {
                isFromLeft = false;
            }
            if(!isFromLeft){
                for(int i = 0 ,j = eleres.size() - 1;i<j;i++,j--){
                    Integer tmp = eleres.get(i);
                    eleres.set(i,eleres.get(j));
                    eleres.set(j,tmp);
                }
            }
            res.add(eleres);
            ilayer++;
        }
        return res;
    }
}

方法二 stack 实现上层先遍历的结点的子结点下层后遍历

/**
 * 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<>();
        Stack<TreeNode> stack = new Stack<>();
        if(root==null) return res;
        int ilayer = 1;
        boolean isFromLeft = true;
        stack.push(root);
        while (!stack.isEmpty()){
            List<Integer> eleres = new ArrayList<>();
            Stack<TreeNode> tstack = new Stack<>();
            while (!stack.isEmpty()){
                TreeNode tnode =  stack.pop();
                eleres.add(tnode.val);
                if(ilayer %2 == 1){
                    if(tnode.left != null)  tstack.push(tnode.left);
                    if(tnode.right != null) tstack.push(tnode.right);
                }
                else {
                    if(tnode.right != null) tstack.push(tnode.right);
                    if(tnode.left != null)  tstack.push(tnode.left);
                }
            }
            res.add(eleres);
            ilayer ++;
            stack = tstack;
        }
        return res;
    }
}