关于二叉树问题2

问题一：检查两个数是否相同

public boolean isSameTree(treeNode p, treeNode q){
        //分为三种情况
        // 一、两个树都为空
        // 二、两个树其中一个为空
        // 三、两个数都不为空
        if(p==null&&q==null){
            return true;
        }
        if(p==null||q==null){
            return false;
        }
        //接下来处理都不为null的情况
        //先判断根节点是否相同
        if(p.val!=q.val){
            //两个树的根节点不同
            return false;
        }
        return isSameTree(p.left,q.left)&&isSameTree(p.right,q.right);
    }

问题二：求另一个树的子树

给定两个非空二叉树s,t,检验s中是否包含和t具有相同结构和节点值的子树，s的一个子树包括s的一个节点和这个节点的所有子孙，s可以看做它自身的一颗子树

public boolean isSubTree(treeNode s,treeNode t){
        if(s==null&&t==null){
            return true;
        }
        if(s==null||t==null){
            return false;
        }
        boolean ret=false;
        if(s.val==t.val){
            //两个树根节点的值相同，接下来判定s和t是不是相同的树
            ret=isSameTree(s,t);
        }
        //不是相同的树
        if(!ret){
         //s、t不相同，递归看s.left是否包含t，
         ret=isSubTree(s.left,t);
        }
        if(!ret){
            //s.left不包含，看s.right是否包含
            ret=isSubTree(s.right,t);
        }
        return ret;
    }

问题三：二叉树的最大深度

 public int maxDepth(treeNode root){
        if(root==null){
            return 0;
        }
        if(root.left==null&&root.right==null){
           //只有根节点
           return 1;
        }
        //return 1+(maxDepth(root.left)>maxDepth(root.right)?maxDepth(root.left):maxDepth(root.right));
        int leftDepth=maxDepth(root.left);
        int rightDepth=maxDepth(root.right);
        return 1+(leftDepth>rightDepth?leftDepth:rightDepth);
    }

问题四：判断一颗二叉树是否是平衡二叉树

一个数是否平衡=>自己左右子树高度差<=1&&左子树是平衡数&&右子树是平衡树

 public boolean isBalanced(treeNode root){
        if(root==null){
            //空树
            return true;
        }
        if(root.left==null&&root.right==null){
            //只有根节点
            return true;
        }
        //看当前节点对应的子树是否是平衡树
        int leftDepth=maxDepth(root.left);
        int rightDepth=maxDepth(root.right);

        if(leftDepth-rightDepth>1||leftDepth-rightDepth<-1){
            return false;
        }
        return isBalanced(root.left)&&isBalanced(root.right);
    }

问题五：对称二叉树

public boolean isSymetric(treeNode root){
        if(root==null){
            return true;
        }
        return isMirror(root.left,root.right);
    }

    private boolean isMirror(treeNode t1,treeNode t2){
        if(t1==null&&t2==null){
            return true;
        }
        if(t1==null||t2==null){
            return false;
        }
        if(t1.val!= t2.val){
            //两个树的根节点值不同，不是镜像
            return false;
        }
        return isMirror(t1.left,t2.right)&&isMirror(t1.right,t2.left);
    }

问题六：层序遍历

public void levelOder(treeNode root){
        //借助队列实现
        //初始情况下，创建一个空队列并且把根节点加入队列中
        //循环取出队首元素。访问该元素
        //再看当前元素的右子树，如果也为空也加入队列
        Queue<treeNode> queue=new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            treeNode cur=queue.poll();

            //访问元素
            System.out.println(cur.val+"");

            //把左右子树入队列
            if(cur.left!=null){
                queue.offer(cur.left);
            }
            if(cur.right!=null){
                queue.offer(cur.right);
            }
        }
    }