103. Binary Tree Zigzag Level Order Traversal

描述

主要是层次遍历相关的事情
之字形打印二叉树的基本情况
首先从左走到右，接下来一层从右走到左的基本情况

关于这到题目也可以查看下
102 层次遍历并保存每层的结果构成一个collectons

102. Binary Tree Level Order Traversal

层次遍历 BFS

队列中的元素个数其实就是每层节点中的个数， 在while(循环体操作之前我们是可以)

层次遍历中， 利用每层队列中 队列格式进行的情况， 每一层进行一遍处理

while(队列不为空){
    int num = 队列中的大小；
     // 处理每一层的节点数目情况 
     for(int 0;i<num;i++){
    }
    就是每层节点的数目
}

实际上这种办法是BFS， 只不过这种时间复杂度为O(n), n 个节点的情况

public class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        List<List<Integer>> wrapList = new LinkedList<List<Integer>>();
        
        if(root == null) return wrapList;
        
        queue.offer(root);
        while(!queue.isEmpty()){
            int levelNum = queue.size();
            List<Integer> subList = new LinkedList<Integer>();
            for(int i=0; i<levelNum; i++) {
                if(queue.peek().left != null) queue.offer(queue.peek().left);
                if(queue.peek().right != null) queue.offer(queue.peek().right);
                subList.add(queue.poll().val);
            }
            wrapList.add(subList);
        }
        return wrapList;
    }
}

DFS

深度优先搜索遍历, 其实这道题目也是跟排列组合那道题目一样的解法情况， 使用一个变量depth标记每个节点的层次关系， 按照层次关系进行添加，
第一层， 第二层，，，。。。。。 最后一层

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
     List<List<Integer>> result= new LinkedList<>();
     if(root==null){
         return result;
     }
        
     return helper(root, 1,  result);
    }
     private List<List<Integer>>helper(TreeNode root, int depth, List<List<Integer>> result){
         if(root==null){
             return null;
         }
         // 为下一次结果进行， = 等号主要是为了第一层的添加，  depth, 就是没有添加往才
         if(depth>result.size()){
             result.add(new LinkedList<>());
         }
         result.get(depth-1).add(root.val);  // 
         helper(root.left, depth+1, result);
         helper(root.right, depth+1,result );
         return result;
     }
}

103. Binary Tree Zigzag Level Order Traversal

深度优先搜索

对深度加入一个元素进行判断即可， 是中间， depth中间元素， 判断

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
     //利用层次遍历的基本情况
     //该种情况如何处理
     // 元素可以从中间左右两边进行一个基本情况的添加
     List<List<Integer>>result = new LinkedList<>();
     if(root==null)
          return result;
     helper(root, result, 0);
          return result;
    }
    private void helper(TreeNode root,  List<List<Integer>> result, int depth){
         if(root==null)
             return;
         if(depth >= result.size())
             result.add(new LinkedList<>());
        // 在这里取出一个元素而已， 实质上并没有改变原来的元素情况，
       //  List<Integer> collection = result.get(depth);
         if(depth % 2== 0){
               result.get(depth).add(root.val);
         }
         else{
            result.get(depth).add(0,root.val);
         }
         helper(root.left, result, depth+1);
         helper(root.right, result, depth+1);
    }
}

层次遍历

利用一个标记位来标记一个东西是层数， 注意的是出队列过程添加一个判断是否为空的队列即可

/**
 * 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>>result = new LinkedList<>();
     Deque<TreeNode> queue = new LinkedList<>();
     int len =0;
     queue.offer(root);
     
    if(root==null)
        return result;
    while(!queue.isEmpty()){
        
         
         // 在前面就应该知道队列当中的元素情况的话，
         int number= queue.size();
         // 一次循环处理一层元素情况， 所以在这里的话
         List<Integer> tmp=new LinkedList<>();
         result.add(tmp);
         
         for(int i=0;i<number;i++)
         {
             // 如果是在这个过程当中就把元素
           TreeNode  deal = queue.peek();
              if(deal==null)
                  return null;
             if( len% 2==0 )
                  tmp.add(deal.val);
             else 
                  tmp.add(0,deal.val);
             if(deal.left!=null)
                 queue.offer(deal.left);
             if(deal.right!=null)
                queue.offer(deal.right);
            queue.poll();
             
         }
           ++len;
     }
     return result;
    }
}