二叉树六道基本习题，你都会了吗？

Hello大家好呀，本博客目的在于记录暑假学习打卡，后续会整理成一个专栏，主要打算在暑假学习完数据结构，因此会发一些相关的数据结构实现的博客和一些刷的题，个人学习使用，也希望大家多多支持，有不足之处也请指出，谢谢大家。

一，判断两棵树是否相同

. - 力扣（LeetCode）

先判断结构是否相同，在判断数值是否相同，结构相同的话，通过递归判断每一个节点

class Solution {
    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);
           


    }
}

二，另一棵树的子树

. - 力扣（LeetCode）

此题用到了判断两棵树是否相同的方法，需要注意的是再遍历传参时，子树是不变的，需要通过遍历找出非子树的与之匹配的节点（同样分左数和右数）

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if (root==null)return false;
        if (isSameTree(root,subRoot)) return true;
        if (isSubtree(root.left,subRoot)) return true;
        if (isSubtree(root.right,subRoot)) return true;
        return false;
    }

    public boolean isSameTree(TreeNode p, TreeNode q) {
        // 1.先判断结构是否是一样的
        if (p != null && q == null || p == null && q != null) {
            return false;
        }
        // 上述if语句 如果没有执行，意味着两个引用 同时为空 或者同时不为空
        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);
    }
}

三，翻转二叉树

. - 力扣（LeetCode）

遍历，翻转，非常简单

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null){
            return null;
        }else{
            TreeNode tmp=root.left;
            root.left=root.right;
            root.right=tmp;
        }
        invertTree(root.right);
        invertTree(root.left);
        return root;

    }
}

四，求二叉树的高度

求二叉树的高度同样是通过递归，比较简单，再后面求平衡二叉树中也有运用

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

五，平衡二叉树

. - 力扣（LeetCode）

平衡二叉树指每一个节点左右子树高度差不超过一的树，按照条件做即可，需注意在递归时我们把递归的返回值作为条件，这样便保证了每一个节点都符合条件才返回true

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isBalanced(TreeNode root) {
        if(root==null){
            return true;
        }
        if(getheight(root.left)-getheight(root.right)>1||
       getheight(root.left)-getheight(root.right)<-1){
        return false;
       }
       if(isBalanced(root.left)&&isBalanced(root.right)){
        return true;
       }
       return false;
    }
    public int getheight(TreeNode root){
        if(root==null){
            return 0;
        }
        int LeftHeight=getheight(root.left);
        int RightHeight=getheight(root.right);
        return Math.max(LeftHeight,RightHeight)+1;
    }
}

六，对称二叉树

. - 力扣（LeetCode）

对称二叉树，重在判断左树和右数是否对称，这时需要用到判断数相同的部分代码，不同的是，此时是左数的右孩子和右数的左孩子相等或者左数的左孩子和右数的右孩子相等，时间复杂度尾O（N^2）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 * int val;
 * TreeNode left;
 * TreeNode right;
 * TreeNode() {}
 * TreeNode(int val) { this.val = val; }
 * TreeNode(int val, TreeNode left, TreeNode right) {
 * this.val = val;
 * this.left = left;
 * this.right = right;
 * }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if (root == null) {
            return true;
        }

        return isTree(root.left, root.right);
    }

    public boolean isTree(TreeNode Left, TreeNode Right) {
        if (Left == null && Right == null) {
            return true;
        }
        if (Right == null && Left != null ||
                Left == null && Right != null) {
            return false;
        }
        if (Left.val != Right.val) {
            return false;
        }
       
        return  isTree(Left.left, Right.right)&&
        isTree(Left.right, Right.left);

    }
}

另外，此题还有时间复杂度尾O（N）的解放，不过笔者还没搞懂以后会发出

本篇博客就到这里，谢谢大家。