Leecode 102、103 Binary Tree Zigzag Level Order Traversal Z型层次遍历二叉树，外加正常的层次遍历

首先应当知道java中LinkedList既ke可以充当队列，也可充当栈。既让是Z型的话，选用LinkedListgeng更方便。

题目如下：

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

第一种解决办法如下：

package test;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LC103Try3
{
	public List<List<Integer>> zigzagLevelOrder(TreeNode root)
	{
		List<List<Integer>> ret = new ArrayList<List<Integer>>();
		getPass(root,ret,0);
		return ret;
	}

	public void getPass(TreeNode root,List<List<Integer>> ret,int level){
		if(root == null){
			return;
		}
		//这一步还容易错
		if(ret.size()-1<level){
			ret.add(new LinkedList<Integer>());
		}
		//linkedList可以充当队列，也可以充当栈它有addFirst方法
		if(level%2==1){
			((LinkedList<Integer>)ret.get(level)).addFirst(root.val);
		}else{
			ret.get(level).add(root.val);
		}
		getPass(root.left,ret,level+1);
		getPass(root.right,ret,level+1);
	}
}

第二种解决办法：稍微慢一点

package test;

import java.util.ArrayList;
import java.util.List;
//Z型层次遍历
public class LC103Try2
{
	public List<List<Integer>> zigzagLevelOrder(TreeNode root)
	{
		List<List<Integer>> ret = new ArrayList<List<Integer>>();
		if (root == null)
		{
			return ret;
		}
		List<TreeNode> lastList = new ArrayList<TreeNode>();
		List<TreeNode> thislist = new ArrayList<TreeNode>();
		lastList.add(root);
		int deep = 0;
		List<Integer> listval = new ArrayList<Integer>();
		while (lastList.size() > 0)
		{
			if (deep % 2 == 0)
			{
				for (int i = lastList.size() - 1; i >= 0; i--)
				{
					TreeNode node = lastList.get(i);
					listval.add(node.val);

					if (node.left != null)
					{
						thislist.add(node.left);
					}
					if (node.right != null)
					{
						thislist.add(node.right);
					}

				}
			}else{
				for (int i = lastList.size() - 1; i >= 0; i--)
				{
					TreeNode node = lastList.get(i);
					listval.add(node.val);

					if (node.right != null)
					{
						thislist.add(node.right);
					}
					if (node.left != null)
					{
						thislist.add(node.left);
					}

				}
				
			}
			
			deep++;
			ret.add(listval);
			listval = new ArrayList<Integer>();
			lastList = thislist;
			thislist = new ArrayList<TreeNode>();
		}

		return ret;
	}

	public void getPass(TreeNode root, List<List<Integer>> ret,
			List<TreeNode> lastList, List<TreeNode> thislist)
	{

	}

}

 

public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ret=new ArrayList<>();
        if(root==null){
            return ret;
        }
        Deque<TreeNode> stack=new LinkedList<>();
        stack.push(root);
        int tag=1;
        while(stack.size()>0){
            int size= stack.size();
            List<Integer> list=new ArrayList<>();
            Deque<TreeNode> st=new LinkedList<>();
            for(int i=0;i<size;i++){
                TreeNode p=stack.pop();
                if(tag%2!=0){
                    if(p.left!=null){
                        st.push(p.left);
                    }
                    if(p.right!=null){
                        st.push(p.right);
                    }
                }else{//satck 自动实现，倒序，所以插入的时候还是要有左右的倒序的
                    if(p.right!=null){
                        st.push(p.right);
                    }
                    if(p.left!=null){
                        st.push(p.left);
                    }

                }

                list.add(p.val);

            }
            tag++;
            ret.add(list);
            stack=st;

        }
        return ret;


    }

正常的层次遍历：

第一种办法

package test;

import java.util.ArrayList;
import java.util.List;
//正常的层次遍历
public class LC103Try1
{
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
    	List<List<Integer>> ret= new ArrayList<List<Integer>>();
    	if(root==null){
    		return ret;
    	}
    	List<TreeNode> list= new ArrayList<TreeNode>();
    	List<Integer> listval=new ArrayList<Integer>();
    	list.add(root);
    	int index=0;    	
    	for(int start=0;start<list.size();start++){
    		TreeNode node=list.get(start);
    		listval.add(node.val);
    		if(node.left!=null){
    			list.add(node.left);
    		}
    		if(node.right!=null){
    			list.add(node.right);
    		}
    		if(start==index){    			
    			ret.add(listval);
    			listval=new ArrayList<Integer>();    			
    			index=list.size()-1;    			   			
    		}
    	}
    	
    	return ret;
    }
   

}

 

public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ret=new ArrayList<>();
        if(root==null){
            return ret;
        }
        Deque<TreeNode> stack=new LinkedList<>();
        stack.push(root);
        while(stack.size()>0){
            int size= stack.size();
            List<Integer> list=new ArrayList<>();
            for(int i=0;i<size;i++){
                TreeNode p=stack.pollLast();
                list.add(p.val);
                if(p.left!=null){
                    stack.push(p.left);
                }
                if(p.right!=null){
                    stack.push(p.right);
                }
            }
            ret.add(list);

        }

        return ret;
    }

 

第二种办法：

package test;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class LC103Try12
{
	public List<List<Integer>> zigzagLevelOrder(TreeNode root)
	{
		List<List<Integer>> ret = new ArrayList<List<Integer>>();
		getPass(root,ret,0);
		return ret;
	}

	public void getPass(TreeNode root,List<List<Integer>> ret,int level){
		if(root == null){
			return;
		}
		//这一步还容易错
		if(ret.size()-1<level){
			ret.add(new ArrayList<Integer>());
		}
		
		ret.get(level).add(root.val);
		
		getPass(root.left,ret,level+1);
		getPass(root.right,ret,level+1);
	}

}

哈哈