java-leetcode二叉树遍历；判断相同；判断子树；最大深度；判断平衡；判断镜像对称；层序遍历

package TestTree;

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

class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}
public class InterviewTree {

    //1.二叉树的前序遍历，返回结果添加到List
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            //空树返回一个空的List（元素个数为0，但是不是null）
            return result;
        }
        //访问根节点，此处的访问操作，把元素add到List中
        result.add(root.val);
        //递归遍历左子树，把左子树的遍历结果加入到List中
        result.add(preorderTraversal(root.left));
        //递归遍历右子树，把右子树的遍历结果加入到List中
        result.add(preorderTraversal(root.right));
        return result;
    }

    //2.二叉树的中序遍历，返回结果添加到List
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            //空树返回一个空的List（元素个数为0，但是不是null）
            return result;
        }
        //递归遍历左子树，把左子树的遍历结果加入到List中
        result.add(inorderTraversal(root.left));
        //访问根节点，此处的访问操作，把元素add到List中
        result.add(root.val);
        //递归遍历右子树，把右子树的遍历结果加入到List中
        result.add(inorderTraversal(root.right));
        return result;
    }

    //3.递归判断两棵二叉树是否相同
    public boolean isSameTree(TreeNode p,TreeNode q) {
        if (p == null && q == null) {
            return true;
        }
        //由于上面的条件，p，q不会同时为null，只有一个为null，一个不为null才能进入该条件内部
        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);
    }

    //4.判断一棵树是否是另一棵树的字数==判断一棵树和另外一颗树的某个子树是否相同
        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的左子树是否包含t
                ret = isSubtree(s.left,t);
            }
            if (!ret) {
                //s.left也不包含t，再看s.right是否包含t
                ret = isSubtree(s.right,t);
            }*/
            return ret || isSubtree(s.left,t) || isSubtree(s.right,t);
        }

        //5.二叉树的最大深度
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            return 1;
        }
/*        //递归要执行三组
        return 1 + ((maxDepth(root.right) > maxDepth(root.left)) ? maxDepth(root.right) : maxDepth(root.left));*/
          //递归只执行两组
        int leftDepth = maxDepth(root.left);
        int rightDepth = maxDepth(root.right);
        return 1 + (leftDepth > rightDepth) ? leftDepth : rightDepth;
    }

    //6.给定一棵二叉树，判断它是否是高度平衡的二叉树
    //空树，或者无子树：平衡
    //针对当前节点，求左右子树的高度，看差值是否大于一
    //递归判定该树的左右子树是否平衡
     //自己的左右子树高度差<1 && 左子树是平衡的 && 右子树是平衡的
    //这个程序的运行效率比较低，进行了不少重复运算，很多子树的深度可能被重复求了很多次。
    // 优化的方法是：空间换时间，即使用一个额外的Map结构记录某个子树的深度（key：节点，value：深度），下次用到这个深度时直接查表，不必重复递归。
    public boolean isBalanced(TreeNode root) {
        if (root == null || (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);

    }

    //7.给定一个二叉树，检查它是否是镜像对称的
    //A和B的根节点是否相同 && A.left和B.right是否是镜像关系 && A.right和B.left是否是镜像关系
    public boolean isSymmetric(TreeNode root) {
        if (root == null || (root.left == null && root.right == 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);
    }

    //8.层序遍历
    public void levelOrder(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);
            }
        }
    }
}