LeetCode刷题——190416

LeetCode104二叉树的最大深度

题目：

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

思路:

递归

代码:

    public int maxDepth(TreeNode root) {
        if(root==null)
            return 0;
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        return   Math.max(left,right)+1;        
    }

LeetCode 102二叉树的层次遍历

题目

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

思路1

使用队列实现

代码1

    public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        if(root==null)
            return new ArrayList<ArrayList<Integer>>();
        
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int count = queue.size();
            ArrayList<Integer> cur = new ArrayList<>();
            while(count-->0){
                TreeNode temp = queue.poll();
                cur.add(temp.val);
                if(temp.left!=null) queue.offer(temp.left);
                if(temp.right!=null) queue.offer(temp.right);
            }
            res.add(cur);
        }
        return res;
    }

思路2：

递归

代码2：

    public List<List<Integer>> levelOrder(TreeNode root) {
     List<List<Integer>> res = new ArrayList<List<Integer>>();
     helper(root,0,res);     
     return res;
    }
    
    private void helper(TreeNode root,int level,List<List<Integer>> res) {
     if(root==null) return;
     //如果此时level==res.size(),说明要开始新的一层的遍历，需要新建一个list
     //一开始level=0,res.size()=0,说明此时要开始第一层节点的遍历
     //level=1时，res.size()=1;而已经开始处理第二层节点（即root的子节点），所以需要new一个list存放子节点
     if(level==res.size())
      res.add(new ArrayList<Integer>());
     res.get(level).add(root.val);
     if(root.left!=null) helper(root.left,level+1,res);
     if(root.right!=null) helper(root.right,level+1,res);    
    }

LeetCode103二叉树的锯齿形层次遍历

题目：

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

思路1：

与102一致
提供一个标志位：startLeft
如果该层数据应该从左往右输出，那么顺序添加到cur中；
如果该层数据应该从右往左输出，那么从头开始逐个添加到cur中

代码1：

    public ArrayList<ArrayList<Integer>> zigzagLevelOrder(TreeNode root) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        if(root==null) return res;
        
        boolean startLeft = true;//level为偶数从左往右遍历；level为奇数从右往左便利   
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
         ArrayList<Integer> cur = new ArrayList<>();
         int count = queue.size();
         while(count-->0) {
          TreeNode temp = queue.poll();
          if(temp.left!=null) queue.offer(temp.left);
          if(temp.right!=null) queue.offer(temp.right);
          if(startLeft)
           cur.add(temp.val);
          else
           cur.add(0, temp.val);
         }
         res.add(cur);
         startLeft=!startLeft;
        }
  return res;
    }

思路2：

按照102，顺序添加，获得res
取res中的奇数行（从0开始），翻转列表即可（违背了之字形遍历的意图）

思路3:

栈（剑指offer上，具体不记得了，看看书）

LeetCode101.对称二叉树

题目

给定一个二叉树，检查它是否是镜像对称的。

思路1：

递归
树镜像对称，则左子树的值等于右子树的值（不能只考虑这个条件，因为这样只考虑了两层即1，2，2，没办法保证两颗子树的堆成）
并且海要判断左子树的左儿子等于右子树的右儿子

代码1：

    public boolean isSymmetric(TreeNode root) {
        if(root==null) return true;     
        return isSymmetric(root.left,ro**加粗样式**ot.right);
         }
    
    private boolean isSymmetric(TreeNode t1,TreeNode t2) {
     if(t1==null&&t2==null)
      return true;
     
     if(t1==null||t2==null)
      return false;
     
     return t1.val==t2.val&&isSymmetric(t1.left,t2.right)&&isSymmetric(t1.right,t2.left); 
    }

思路2：

非递归法（不知道是不是迭代）
使用queue实现层次遍历。在入队列的时候按照规则的顺序入队列

代码2：

     public boolean isSymmetric(TreeNode root) {
      if(root==null)
       return true;
      
      Queue<TreeNode> queue = new LinkedList<>();
      queue.offer(root.left);
      queue.offer(root.right);
      while(!queue.isEmpty()) {
       int count = queue.size();
       while(count>0) {
        TreeNode left = queue.poll();
        TreeNode right = queue.poll();
        count -= 2 ;
        if(left==null&&right==null)
         continue;
        if(left==null||right==null||left.val!=right.val)
         return false;
        
        queue.offer(left.left);
        queue.offer(right.right);
        queue.offer(left.right);
        queue.offer(right.left);        
       }       
      }
      return true;
     }