剑指 Offer 26树的子结构(相关话题：对称性递归,在线算法)

目录

开篇引言

题目描述

代码实现

题目拓展

拓展解读

一类

100. 相同的树

226. 翻转二叉树

104. 二叉树的最大深度

110. 平衡二叉树

543. 二叉树的直径

617. 合并二叉树

572. 另一个树的子树

965. 单值二叉树

二类

101. 对称二叉树

解题总结

---

开篇引言

力扣上很多树的题目都是可以用递归很快地解决的，而这一系列递归解法中蕴含了一种很强大的递归思维：对称性递归(symmetric recursion) 什么是对称性递归？就是对一个对称的数据结构（这里指二叉树）从整体的对称性思考，把大问题分解成子问题进行递归，即不是单独考虑一部分(比如树的左子树)，而是同时考虑对称的两部分(左右子树)，从而写出对称性的递归代码。

题目描述

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

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

例如:
给定的树 A:

     3
    / \
   4   5
  / \
 1   2
给定的树 B：

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

示例 1：

输入：A = [1,2,3], B = [3,1]
输出：false

示例 2：

输入：A = [3,4,5,1,2], B = [4,1]
输出：true

代码实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    /*
     * 死死记住isSubStructure()的定义:判断B是否为A的子结构
     */
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        // 若A与B其中一个为空,立即返回false
        if(A == null || B == null) {
            return false;
        }
        // B为A的子结构有3种情况,满足任意一种即可:
        // 1.B的子结构起点为A的根节点,此时结果为recur(A,B)
        // 2.B的子结构起点隐藏在A的左子树中,而不是直接为A的根节点,此时结果为isSubStructure(A.left, B)
        // 3.B的子结构起点隐藏在A的右子树中,此时结果为isSubStructure(A.right, B)
        return recur(A, B) || isSubStructure(A.left, B) || isSubStructure(A.right, B);
    }

    /*
    判断B是否为A的子结构,其中B子结构的起点为A的根节点
    */
    private boolean recur(TreeNode A, TreeNode B) {
        // 若B走完了,说明查找完毕,B为A的子结构
        if(B == null) {
            return true;
        }
        // 若B不为空并且A为空或者A与B的值不相等,直接可以判断B不是A的子结构
        if(A == null || A.val != B.val) {
            return false;
        }
        // 当A与B当前节点值相等,若要判断B为A的子结构
        // 还需要判断B的左子树是否为A左子树的子结构 && B的右子树是否为A右子树的子结构
        // 若两者都满足就说明B是A的子结构,并且该子结构以A根节点为起点
        return recur(A.left, B.left) && recur(A.right, B.right);
    }
}

题目拓展

 可以用对称性递归解决的二叉树问题大多是判断性问题(bool类型函数),这一类问题又可以分为以下两类：

1、不需要构造辅助函数。这一类题目有两种情况：第一种是单树问题，且不需要用到子树的某一部分(比如根节点左子树的右子树)，只要利用根节点左右子树的对称性即可进行递归。第二种是双树问题，即本身题目要求比较两棵树，那么不需要构造新函数。该类型题目如下：

100. 相同的树

226. 翻转二叉树

104. 二叉树的最大深度

110. 平衡二叉树

543. 二叉树的直径

617. 合并二叉树

572. 另一个树的子树

965. 单值二叉树

2、需要构造辅助函数。这类题目通常只用根节点子树对称性无法完全解决问题，必须要用到子树的某一部分进行递归，即要调用辅助函数比较两个部分子树。形式上主函数参数列表只有一个根节点，辅助函数参数列表有两个节点。该类型题目如下：

101. 对称二叉树 

剑指 Offer 26. 树的子结构

拓展解读

一类

100. 相同的树

public boolean isSameTree(TreeNode p, TreeNode q) {
 
      
       if(p==q && p==null){
           return true;
       }
       if(p==null && q!=null){
           return false;
       }
       if(p!=null && q==null){
           return false;
       }

       TreeNode lleft =   p.left;
       TreeNode lright =  p.right;

       TreeNode rleft =   q.left;
       TreeNode rright =  q.right;

       if(p.val!=q.val){
           return false;
       }
 

       return isSameTree(lleft,rleft) && isSameTree(lright,rright);
     
}

226. 翻转二叉树

public TreeNode invertTree(TreeNode root) {

		if(root==null) {
			return null;
		}
		//下面三句是将当前节点的左右子树交换
		TreeNode tmp = root.right;
		root.right = root.left;
		root.left = tmp;

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

        return root;
}

104. 二叉树的最大深度

public int maxDepth(TreeNode root) {

        int leftDepth = 0;
        int rightDepth = 0;
        if(root==null){
           return 0;
        }
        if(root.left==null && root.right==null){
            return 1;
        }

        if(root.left!=null){
             leftDepth =   maxDepth(root.left)+1;
        }
        if(root.right!=null){
             rightDepth =   maxDepth(root.right)+1;
        }

        return Math.max(leftDepth,rightDepth);

}

110. 平衡二叉树

 public boolean isBalanced(TreeNode root) {

    if(root==null){
        return true;
    }
  
      return Math.abs(getHeght(root.left)-getHeght(root.right))<2 && isBalanced(root.left) && isBalanced(root.right);
   
   
}


public int getHeght(TreeNode root){

       if(root==null){
           return 0;
       }

        return Math.max(getHeght(root.left),getHeght(root.right))+1;
}

543. 二叉树的直径

int diameter;

public int diameterOfBinaryTree(TreeNode root) {
    diameter = 0;
    traverse(root);
    return diameter;
}

// 返回树的深度
int traverse(TreeNode root) {
    if (root == null) {
        return 0;
    }

    int left = traverse(root.left); // 左子树的深度
    int right = traverse(root.right); // 右子树的深度
    // 直接访问全局变量
    diameter = Math.max(diameter, left + right);
    return 1 + Math.max(left, right);
}

在这道题中，全局变量计算的是路径的最大值（max）。计算 max 的方式不是一次性求出来的，而是在二叉树遍历的过程中，每出现一个值，就把这个值和全局变量比较计算，算一个最大值。最终全局变量能得到全局的最大值。

实际上这利用了 max 的性质，max 是一种在线算法。简单来说，在线算法就是在计算的时候，所有的输入数据以“流”的形式一个个进来，算法每次只处理一条数据，不需要保存全部的数据。

除了 max 之外，sum、all 也都属于在线算法（all 指的是 x1 && x2 && ... && xn 这样的计算）。可以举几个其他的二叉树题目例子：

二叉树的坡度：563. Binary Tree Tilt（sum）

public int findTilt(TreeNode root) {

     if(root==null){
         return 0;
     }

      int leftSum =  getSum(root.left);
      int rightSum  =    getSum(root.right);

      root.val=  Math.abs(leftSum  -rightSum);

      return root.val + findTilt(root.left) + findTilt(root.right);
} 

public int getSum(TreeNode root){

        if(root==null){
            return 0;
        }

        return root.val + getSum(root.left) + getSum(root.right);
}

判断平衡二叉树：110. Balanced Binary Tree（all）
二叉树路径数字：129. Sum Root to Leaf Numbers（sum）

617. 合并二叉树

把root1作为返回树

public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {

        if(root1==null && root2==null){

           return root1;

        }else if((root1==null && root2!=null) || (root1!=null && root2==null)){

            if(root1==null){
                root1 =new TreeNode(root2.val);
                root1.left = mergeTrees(null,root2.left);
                root1.right = mergeTrees(null,root2.right);
            }else{
                root1.left = mergeTrees(root1.left,null);
                root1.right = mergeTrees(root1.right,null);
            }

        }else{
            root1.val= root1.val + root2.val;
            root1.left = mergeTrees(root1.left,root2.left);
            root1.right = mergeTrees(root1.right,root2.right);
        }

         return root1;
}

返回一个新的树，可以简化代码

public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        if (t1 == null) {
            return t2;
        }
        if (t2 == null) {
            return t1;
        }
        TreeNode merged = new TreeNode(t1.val + t2.val);
        merged.left = mergeTrees(t1.left, t2.left);
        merged.right = mergeTrees(t1.right, t2.right);
        return merged;
}

572. 另一个树的子树

注意子树和子结构的区别：

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

 

 代码可以在本文主题目的基础上稍作修改就可以使用

965. 单值二叉树

int univalVal=-1;

public boolean isUnivalTree(TreeNode root) {

       Boolean flag = true;
       if(root!=null){
            if(univalVal==-1){
                univalVal = root.val;
            }
            if(root.val!=univalVal){
                 flag =false;
            }

            return flag && isUnivalTree(root.left) && isUnivalTree(root.right);
       }

       return true;
 
      
}

二类

101. 对称二叉树

public boolean isSymmetric(TreeNode root) {
		if(root==null) {
			return true;
		}
		//调用递归函数，比较左节点，右节点
		return dfs(root.left,root.right);
}
	
boolean dfs(TreeNode left, TreeNode right) {
		//递归的终止条件是两个节点都为空
		//或者两个节点中有一个为空
		//或者两个节点的值不相等
		if(left==null && right==null) {
			return true;
		}
		if(left==null || right==null) {
			return false;
		}
		if(left.val!=right.val) {
			return false;
		}
		//再递归的比较 左节点的左孩子 和 右节点的右孩子
		//以及比较  左节点的右孩子 和 右节点的左孩子
		return dfs(left.left,right.right) && dfs(left.right,right.left);
}

解题总结

1. 一般来说思维越奇特代码越简洁，官方题解一般代表了“最优代码”，普通的思维不一定可以马上领会，可以退而求其次再优化“思维”简化代码。
2. 在练习中插入两个以上的主题或技能，也是一种胜过集中练习的学 习方法
3. 与集中练习相比，穿插练习与多样化练习的一个显著优点是，它们有助于我们更好地学习如何评估背景，以及辨识问题间的差异，从一系列可选的答案中选择并应用正确的解决方案。
4. 人们顽固地相信，自己把心思放在一件事上，拼命重复就能学得更好，认为这些观点经受住了时间的考验，而且“练习，练习，再练习”的明显收效再次证明了这种方法的好处。但是，科学家们把习得技能阶段的这种成绩称为“暂时的优势”，并把它同“潜在的习惯优势”区分开来。形成习惯优势有种种技巧，例如有间隔的练习、有穿插内容的练习，引出努力的动力。 及多样化练习，这些技巧恰恰会放缓有明显成果的学习进程，它们不会在练习中提高我们的表现。我们从表面上看不到成绩提高，也就没有付出的动力
5. 心智模型可以 被调整，可以在复杂多变的环境中发挥作用。专业的表现，源自在不同 
   环境下、在专长领域进行的数千小时的练习。通过这些练习，你可以积 累大量类似的心智模型，从而保证自己在特定环境下做出正确分析，立 刻挑选出正确的应对方案并加以执行。