leetcode--Binary Tree Zigzag Level Order Traversal

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,#,#,15,7}

,

3
/ \
9  20
/  \
15   7

return its zigzag level order traversal as:

[
[3],
[20,9],
[15,7]
]

题意：给定二叉树，遍历每一层。对于当前层，如果从左到右，则下一层从右到左。

分类：二叉树

解法1：层次遍历。使用一个标记来标记层的结束。每次结束将队列里面的数据保存。

[java] view
plain copy

/** 

 * Definition for a binary tree node. 

 * public class TreeNode { 

 *     int val; 

 *     TreeNode left; 

 *     TreeNode right; 

 *     TreeNode(int x) { val = x; } 

 * } 

 */  

public class Solution {  

    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {  

        Stack<TreeNode> stack = new Stack<TreeNode>();      

        LinkedList<List<Integer>> res = new LinkedList<List<Integer>>();      

        if(root == null) return res;      

        List<Integer> t = new ArrayList<Integer>();      

        int low = 0;      

        int high = 0;      

        int ceng = 0;      

        boolean flag=true;  

        stack.add(root);      

        t.add(root.val);      

        res.add(t);      

        t = new ArrayList<Integer>();;      

        while(low<=high){                  

            TreeNode cur = stack.get(low);                

            if(cur.left!=null){      

                stack.add(cur.left);      

                t.add(cur.left.val);      

                high++;      

            }      

            if(cur.right!=null){      

                stack.add(cur.right);      

                t.add(cur.right.val);      

                high++;      

            }      

            if(low==ceng){      

                if(flag){  

                    Collections.reverse(t);  

                }  

                flag = !flag;  

                if(t.size()!=0) res.add(t);;      

                t = new ArrayList<Integer>();      

                ceng = high;      

            }      

            low++;      

        }      

        return res;      

    }  

}  

解法2：层次遍历。使用LinkedList从而可以在头部添加节点。

使用level来做标记从而省去层次标记。

[java] view
plain copy

/** 

 * Definition for a binary tree node. 

 * public class TreeNode { 

 *     int val; 

 *     TreeNode left; 

 *     TreeNode right; 

 *     TreeNode(int x) { val = x; } 

 * } 

 */  

public class Solution {  

    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {  

        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();//队列，用于层次遍历  

        List<List<Integer>> res = new ArrayList<List<Integer>>();//结果  

        List<Integer> cur = new ArrayList<Integer>();//保留当前层数据  

        if(root==null) return res;  

        boolean lToR = true;//是否从左到右  

        int level = 1;  

        queue.add(root);  

        while(queue.size()>0){  

            TreeNode node = queue.poll();  

            if(lToR)  

                cur.add(node.val);  

            else  

                cur.add(0,node.val);  

  

            if(node.left != null)  

                queue.add(node.left);  

            if(node.right != null)  

                queue.add(node.right);  

            if(--level == 0){  

                level = queue.size();  

                res.add(new ArrayList(cur));  

                cur.clear();  

                lToR = !lToR;  

            }  

        }  

        return res;  

    }  

}  



原文链接http://blog.csdn.net/crazy__chen/article/details/46484543