【Java数据结构 -- 面试题 之 二叉树相关算法1】

1.检查两个树是否相同

思路：整体来看：要判断两棵树是否相同，得同时判断根然后判断两棵树的左子树是否相同和两棵树的右子树是否相同。

1. 如果一个节点为空，另外一个节点不为空，肯定不是相同的树。
2. 如果两个节点都为空，是相同的，如果都不为空，去判断值；
3. 接下来判断结构上一不一样

    public boolean isSameTree(TreeNode p, TreeNode q) {
        if((p == null && q != null) || (q == null && p != null)) {
            return false;
        }
        // 两个全为空
        if(p == null && q == null) {
            return true;
        }

        // 两个全为不空
        if(p.val != q.val) {
            return false;
        }

        // p != null && q != null) && p.val == q.val 即两个不为空且值相等
        //接下来判断结构上一不一样
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }

2.一颗树的子树是否和另一颗树相同

root的子树和另一棵树subRoot
思路：

1. 是不是和根节点相同
2. 判断是不是和root的左子树相同
3. 判断是不是和root的右子树相同
4. 最后都不是返回false

    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if (root == null || subRoot == null) {
            return false;
        }
        //1.是不是和根节点相同
        if (isSameTree(root,subRoot)) {
            return true;
        }
        //2.判断是不是root的左子树
        if (isSubtree(root.left,subRoot)) {
            return true;
        }
        //3.判断是不是root的右子树
        if (isSubtree(root.right,subRoot)) {
            return true;
        }
        //4.返回
        return false;
    }
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if ((p == null && q != null) || (q == null && p != null)) {
            return false;
        }
        if (p == null && q == null) {
            return true;
        }
        if (p.val != q.val) {
            return false;
        }
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }

3. 翻转二叉树

思路：只要遍历到这个节点，就把这个节点的两个引用换一下直到所有的节点遍历完。其叶子节点不需要换

    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }
        // 走到叶子节点不需要换
        if (root.left == null && root.right == null) {
            return root;
        }
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;

        invertTree(root.left);
        invertTree(root.right);
        return root;
    }

4.判断一颗二叉树是否是平衡二叉树

思路：

1. 先求每个节点的左子树和右子树的高度
2. 当前根节点的左树 - 右树 的绝对值 <= 1&& 根的左树平衡 && 右树平衡 即是平衡的

该方法的时间复杂度为：O(n^2)

    public boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.left);

        return Math.abs(leftHeight-rightHeight) <= 1 && isBalanced(root.left) && isBalanced(root.right);
    }
    // 求树的高度，思路 ： 整棵树的高度 = 左子树的高度 和 右子树的高度 最大值 + 1
    int getHeight(TreeNode root){
        if(root == null) {
            return 0;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);

        return leftHeight > rightHeight ? leftHeight + 1:rightHeight + 1;
    }

5.也同样判断二叉树是否是平衡二叉树，要求时间复杂度为O(n)

思路：一边求高度一边判断平衡

    public boolean isBalanced2(TreeNode root) {
        if (root == null) {
            return true;
        }
        return maxLength(root) >= 0;
    }
    public int maxLength(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = maxLength(root.left);
        if (leftHeight < 0) {
            return -1;
        }
        int rightHeight = maxLength(root.right);
        if (leftHeight >= 0 && rightHeight >= 0 && Math.abs(leftHeight-rightHeight) <= 1) {
            // 返回真实的高度
            return Math.max(leftHeight,rightHeight) + 1;
        }else {
            return -1;
        }
    }