leetcode-103-二叉树的锯齿形层次遍历(binary tree zigzag level order traversal)-java

题目及测试

package pid103;

import java.util.List;

/* 二叉树的锯齿形层次遍历

给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。

例如：
给定二叉树 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回锯齿形层次遍历如下：

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



}*/
public class main {
	
	public static void main(String[] args) {
		Object[] x=new Object[]{1,2,3,4,null,null,5};	
		BinaryTree tree=new BinaryTree(x);
		tree.printTree(tree.root);
		test(tree.root);
		
		Object[] x2=new Object[]{3,9,20,null,null,15,7};	
		BinaryTree tree2=new BinaryTree(x2);
		tree2.printTree(tree2.root);
		test(tree2.root);
		
	}
		 
	private static void test(TreeNode ito) {
		Solution solution = new Solution();
		List> rtn;
		long begin = System.currentTimeMillis();
		rtn = solution.zigzagLevelOrder(ito);//执行程序
		long end = System.currentTimeMillis();		
		System.out.println("rtn=" );
		for (List list : rtn) {
			for (Integer integer : list) {
				System.out.print(integer+" ");
			}
			System.out.println();
		}

		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

解法1（成功，2ms，较快）

使用典型的二叉树层次化遍历的方法，设置一个队列逐个放入层次化的二叉树，设置num，next变量控制层数，然后设置isLTR变量，表明该层的数据从左往右还是从右往左，如果从右往左，则每层遍历的节点由于是从左往右，则塞入list的顺序是插入头部，导致最右的数据在list最左边

package pid103;

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

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
public List> zigzagLevelOrder(TreeNode root) {
     Queue queue=new LinkedList<>();
     List> result=new ArrayList<>();
     LinkedList list=new LinkedList<>();//一排的integer
     if(root==null){
    	 return result;
     }
     queue.add(root);
     int num=1;
     int next=0;
     boolean isLTR=true;//是否这一排顺序从左到右
     while(!queue.isEmpty()){
    	 TreeNode now=queue.poll();   	 
		 if(now.left!=null){
			 queue.add(now.left);
			 next++;
		 }
		 if(now.right!=null){
			 queue.add(now.right);
			 next++;
		 }
		 if(isLTR){
			 list.add(now.val);
		 }
		 else{
			 list.addFirst(now.val);
		 }
    	 num--;
    	 if(num==0){
    		 num=next;
    		 next=0;
    		 isLTR=!isLTR;
    		 result.add(list);
    		 list=new LinkedList<>();
    	 }   	 
     }     
	return result;
    }
}

解法2（别人的）

经典的递归算法，层次遍历二叉树时，可以根据参数depth，知道要加入到List>的哪个list的哪里

class Solution {
    public List> zigzagLevelOrder(TreeNode root) {
        List> res = new ArrayList<>();
        helper(res, root, 0);
        return res;

    }

    private void helper(List> res, TreeNode root, int depth) {
        if (root == null) return;
        if (res.size() == depth) res.add(new LinkedList<>());
        if (depth % 2 == 0) res.get(depth).add(root.val);
        else res.get(depth).add(0, root.val);
        helper(res, root.left, depth + 1);
        helper(res, root.right, depth + 1);
    }
}