剑指offer—day 7（递归：二叉树镜像）

1.剑指 Offer 26. 树的子结构【中等】

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)

B是A的子结构， 即 A中有出现和B相同的结构和节点值。

例如:
给定的树 A:

     3
    / \
   4   5
  / \
 1   2

给定的树 B：

   4 
  /
 1

返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。

思路：

经典递归问题，dfs即可，终结条件
重要的是返回的写法，为或！因为找到一个即可。
下面两个题目都是这个思路展开来的。

bool isSubStructure(TreeNode* A, TreeNode* B) {
        if(A==NULL||B==NULL)
            return 0;
        //找到dfs返回1的结点即为真
        return (dfs(A,B) || isSubStructure(A->left,B) || isSubStructure(A->right,B)); 
    }
    bool dfs(TreeNode* A, TreeNode* B){  //以某个结点为根节点进行判断
        if(B==NULL)                      //匹配返回1，不匹配返回0，对A中所有结点进行dfs即可
            return true;    
        if(A==NULL)
            return false;
        return (A->val==B->val && dfs(A->left,B->left) && dfs(A->right,B->right));
    }

\qquad

2.剑指 Offer 27. 二叉树的镜像【简单】

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

例如输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

镜像输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

示例 1：

输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]

思路

每次交换左右子树，递归对其每个左右子树进行相同操作即可，最后返回root，较为简单的递归。

TreeNode* mirrorTree(TreeNode* root) {
        if(root==NULL)      //终结条件
            return NULL;

        TreeNode *t=root->left;      //交换左右子树
        root->left=root->right;
        root->right=t;

        mirrorTree(root->left);     //向下递归（不需要考虑返回值及其作用）
        mirrorTree(root->right);
        return root;      //最后返回
    }

\qquad

3.剑指 Offer 28. 对称的二叉树【简单】

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [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

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

思路

同上，判断和输出很类似，也是递归对左右子树进行操作，需要注意的是，我们需要分别判断左右子树是否为NULL状态！

bool isSymmetric(TreeNode* root) {
        if(root==NULL)
            return true;
        return compare(root->left,root->right);
    }

    bool compare(TreeNode* A,TreeNode* B){
        if(A==NULL && B== NULL)
            return true;
        else if(A!=NULL && B!=NULL)  //只有在AB均不为空时判定
            return (A->val==B->val && compare(A->left,B->right) && compare(A->right,B->left));
        else   
            return false;    //A、B一个空，一个非空必然错误
    }

本来因为递归很头疼，但是在这样极其清闲的日子里，写起来毫不费力，感觉很简单，很符合人类思维。