leetcode中的二叉树经典问题

Num100-判断两树是否相同

代码实现：

 //判断两棵树是否相同，
        public boolean isSameTree(treeNode p, treeNode q) {
            //都是空树
            if (p == null && q == null) {
                return true;
            }
            //p和q有一个为空
            if (p == null || q == null) {
                return false;
            }
            //p和q都不为空
            if (p.val != q.val) {
                return false;
            }
            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
        }

Num102-层序遍历

//层序遍历
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ret = new LinkedList<>();
        if (root == null) {
            return ret;
        }
        //队列
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        //当前队列还有未访问的元素
        while (!queue.isEmpty()) {
            //保存某层元素
            List<Integer> level = new LinkedList<>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode cur = queue.poll();
                level.add(cur.val);
                //入队左孩子和右孩子
                if (cur.left != null) {
                    queue.offer(cur.left);
                }
                if (cur.right != null) {
                    queue.offer(cur.right);
                }
            }
                ret.add(level);
            }

        return ret;
    }

Num572-另一棵树的子树

代码实现：

//判断一棵树是否是另一棵树的子树

        public boolean isSubtree(treeNode root, treeNode subRoot) {

            //1.边界条件
            if (root == null && subRoot == null) {
                return true;
            }
            if (root == null || subRoot == null) {
                return false;
            }

            //判断root和subRoot是否相同||r.left是否包含s||r.right是否包含s
            return isSameTree(root, subRoot)
            || isSubtree(root.left, subRoot) 
            || isSubtree(root.right, subRoot) ;
        }

        public boolean isSameTree(treeNode p, treeNode q) {
            //都是空树
            if (p == null && q == null) {
                return true;
            }
            //p和q有一个为空
            if (p == null || q == null) {
                return false;
            }
            //p和q都不为空
            if (p.val != q.val) {
                return false;
            }
            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
        }

Num104-二叉树的最大深度

代码实现：

public int height(Node root){
    if(root == null){
        return 0;
    }
    //返回根节点高度1＋左右子树的高度较大值
   return  1 + Math.max(maxDepth(root.left),maxDepth(root.right));
}

Num110-平衡二叉树

平衡二叉树：一个二叉树的每个节点的左右两个子树的高度差的绝对值不超过1。

代码实现：

  import javax.swing.tree.TreeNode;
  import java.util.Map;
  import java.util.HashMap;

  //判断平衡树
public class Num110 {
   
    public boolean isBanlanced(TreeNode root) {
      //判空
      if (root == null) {
        return true;
      }
      //求当前的左右子树高度
      int leftHeight = Height(root.left);
      int rightHeight = Height(root.right);
      int HeightAbs = Math.abs(leftHeight - rightHeight);
      if (HeightAbs > 1) {
        return false;
      }

      //通过递归来判断左右子树是否为平衡二叉树
      public int height (TreeNode root){
        if (root == null) {
          return 0;
        }
        return 1 + Math.Max(Height(root.left), Height(root.right));
      }
    }


      //用map来解决平衡二叉树问题//
      Map<TreeNode Integer> Map = new HashMap<>();
       public boolean isBalanced(TreeNode root){
          //判空
        if(root == null){
          return true;
        }
     //求左右子树的高度
         int leftHeight = 0;
        int rightHeight = 0;

         //判断左树
          if(Map.containsKey(root.left)){
           leftHeight = Map.get(root.left);
           }else{
             leftHeight = height(root.left);
            Map.put(root.left,leftHeight);
          }
        //判断右树
         if (Map.containsKey(root.right){
           rightHeight = Map.get(root.right);
         }else{
          rightHeight = height(root.right);
           Map.put(root.right,rightHeight);
         }

         int HeightAbs = Math.abs(leftHeight - rightHeight);
      if (HeightAbs > 1) {
      return false;
    }
      //通过递归来判断左右子树是否为平衡树
         return isBalanced(root.left)&& isBalanced(root.right);
       }
     public int Height(TreeNode root){
      if(root == null) {
        return 0;
      }
      return 1 + Math.max(Height(root.left),Height(root.right));

      }
}

Num101-对称二叉树

代码实现：

 import javax.swing.tree.TreeNode;
  
  //101对称二叉树

public class Num101 {
    public boolean isSymmetric(TreeNode root) {
        if(root==null){
            return true;
        }
  private boolean isMirror(TreeNode left,TreeNode right){
    //判空
    if(left == null && right == null){
      return true;
    }
    if(left == null || right == null){
      return false;
    }
    
    //左右两树不为空，但数值不相等
     if(left.val != right.val){
       return false;
     }
       return isMirror(left.left,right.right) && isMirror(left.right,right.left);
     }
    }
}

Num完全二叉树

public boolean isCompleteTree(TreeNode root) {
    if (root == null) {
        return true;
    }
    // 层序遍历判断二叉树
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    // 引入标志位，来区分当前遍历过程处在第一还是第二阶段
    boolean isSecondStep = false;
    while (!queue.isEmpty()) {
        TreeNode cur = queue.poll();
        if (!isSecondStep) {
            // 此时处在第一阶段
            if (cur.left != null && cur.right != null) {
                // 当前cur左右子树全部都存在
                queue.offer(cur.left);
                queue.offer(cur.right);
            }else if (cur.left == null && cur.right != null) {
                // 此时只有右树没有左树,反例
                return false;
            }else if (cur.left != null) {
                // 只有左树没有右树,此时cur是碰到的第一个只有左树的节点
                // 切换状态
                isSecondStep = true;
                queue.offer(cur.left);
            }else {
                // 此时左树和右树全部为空，cur第一个碰到的叶子节点
                isSecondStep = true;
            }
        }else {
            // 此时处在第二阶段,第二阶段中的所有节点不可能有子树
            // 有一个反例就false
            if (cur.left != null || cur.right != null) {
                return false;
            }
        }
    }
    // 遍历全部结束，没有找到反例
    return true;
}