100.相同的树；101.对称二叉树；110.平衡二叉树；572.另一个数的子树

这里的四道题目都使用了递归的思想，后面的三道题都是以第一道为基础，加以改进，如果你想对二叉树有更深的认识，不妨耐心看下去:

相同的树

给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
示例 1:

输入: 1        1
        /   \     /   \
      2     3 2     3

    [1,2,3],   [1,2,3]

输出: true
示例 2:
输入: 1    1
        /         \
     2             2

    [1,2],     [1,null,2]

输出: false
示例 3:
输入: 1          1
        /   \       /   \
     2      1   1     2

    [1,2,1],   [1,1,2]

输出: false
两棵树相同的条件是：这两棵树的root值相同且他们的左右子树相同。所以使用递归前序遍历来进行判断；

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    if(p==NULL&&q==NULL){
        return true;
    }
    if(p==NULL||q==NULL){
        return false;
    }
    return p->val==q->val&& isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);
    
}

对称二叉树

给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

           1
          /  \
       2     2
     /   \   /   \
    3   4 4    3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

           1
          /  \
       2     2
         \       \
          3      3

在上个题的基础上，我们只需要将这个树分成左右子树，如果左右子树相同且左右子树的分别的左右子树直到叶子节点都是相同的，那么这个树镜像的

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    if(p==NULL&&q==NULL){
        return true;
    }
    if(p==NULL||q==NULL){
        return false;
    }
    return p->val==q->val&& isSameTree(p->left,q->right)&&isSameTree(p->right,q->left);
    
}
bool isSymmetric(struct TreeNode* root) {
    if(root==NULL){
        return true;
    }
    return isSameTree(root->left,root->right);
}

平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。
示例 1:
给定二叉树 [3,9,20,null,null,15,7]

        3
       /  \
     9    20
           / \
        15  7
返回 true 。
示例 2:
给定二叉树 [1,2,2,3,3,null,null,4,4]

          1
         /  \
       2    2
     /    \
  3       3
  / \
4   4
返回 false 。
依然是运用递归的思想，我们从最后一个非叶子节点开始判断其左右子树高度差只要一出现返回假，就立刻返回假

int get_height(struct TreeNode*root){
    if(root==NULL){
        return 0;
    }
    int left = get_height(root->left);
    int right = get_height(root->right);
    return (left>right?left:right)+1;
}

bool isBalanced(struct TreeNode* root) {
    if(root==NULL){
        return true;
    }
    if(!isBalanced(root->left)){
        return false;
    }
    if(!isBalanced(root->right)){
        return false;
    }
    int diff = get_height(root->left)-get_height(root->right);
    if(diff>=-1&&diff<=1){
        return true;
    }else{
        return false;
    }
}

另一个数的子树

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

嵌套递归，外层递归遍历s树的节点找到与参照子树根节点val相同值的那个，开始里层递归判断是否为同一颗树

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    if(p==NULL&&q==NULL){
        return true;
    }
    if(p==NULL||q==NULL){
        return false;
    }
    return p->val==q->val&& isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);
    
}
bool FindNode(struct TreeNode* s, struct TreeNode* target){
    if (s==NULL){
        return false;
    }
    if(s->val==target->val&&isSameTree(s, target)){
        return true;
    }//根
    bool get = FindNode(s->left, target);
    if(get){return get;}//左
    return FindNode(s->right, target);//右
}
bool isSubtree(struct TreeNode* s, struct TreeNode* t) {
    if(t==NULL){
        return true;
    }
    return FindNode(s,t);
}