Binary Tree Zigzag Level Order Traversal

来源：互联网发布：3d直选遗漏数据统计编辑：程序博客网时间：2024/06/14 08:03

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]]

BFS:

/** * 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) {        List<List<Integer>> lists = new ArrayList<List<Integer>>();        if(root == null) return lists;                LinkedList<TreeNode> current = new LinkedList<TreeNode>();        LinkedList<TreeNode> parent = new LinkedList<TreeNode>();        parent.add(root);        int level = 0;        while(parent.size()!=0){            current = parent;            parent = new LinkedList<TreeNode>();            List<Integer> list = new ArrayList<Integer>();                        while(current.size()!=0){                TreeNode node = current.poll();                if(level %2 == 0){                    list.add(node.val);                } else {                    list.add(0,node.val);                }                if(node.left!=null){                    parent.add(node.left);                }                if(node.right != null){                    parent.add(node.right);                }            }            level++;            lists.add(list);        }        return lists;    }}

BFS2:

/** * 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) {        List<List<Integer>> lists = new ArrayList<List<Integer>>();        if(root == null) return lists;        collect(root, lists);        return lists;    }    public void collect(TreeNode root, List<List<Integer>> lists){        if(root == null) return;        Queue<TreeNode> queue = new LinkedList<TreeNode>();        queue.offer(root);        int level = 0;        while(queue.size()>0){            int size = queue.size();            int count = 0;            ArrayList<Integer> list = new ArrayList<Integer>();            while(count < size) {                TreeNode node = queue.poll();                count++;                if(level%2 == 0){                    list.add(node.val);                } else {                    list.add(0,node.val);                }                if(node.left!=null) {                    queue.offer(node.left);                }                if(node.right!=null) {                    queue.offer(node.right);                }            }            level++;            lists.add(list);        }    }}

DFS:

public class Solution {     public List<List<Integer>> zigzagLevelOrder(TreeNode root) {         List<List<Integer>> lists = new ArrayList<List<Integer>>();         if(root == null) return lists;         collect(lists,root,0);         return lists;     }          public void collect(List<List<Integer>> lists, TreeNode root,int level){         if(root == null) return;                  if(level == lists.size()){             ArrayList<Integer> list = new ArrayList<Integer>();             if(level%2==0){                 list.add(root.val);             }else{                 list.add(0,root.val);             }             lists.add(list);         }else{             List<Integer> list = lists.get(level);             if(level%2 ==0){                 list.add(root.val);             }else{                 list.add(0,root.val);             }         }         collect(lists,root.left,level+1);         collect(lists,root.right,level+1);     } }

0 0