101. 对称二叉树(共含三道leetcode题）

101. 对称二叉树

101. 对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

示例 1：

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

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

提示：

• 树中节点数目在范围 [1, 1000] 内
• -100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？

思路：

首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。

那么遍历的顺序应该是什么样的呢？

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否分别相等。

正是因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

但都可以理解算是后序遍历，尽管已经不是严格上在一个树上进行遍历的后序遍历了。

其实后序也可以理解为是一种回溯，当然这是题外话，讲回溯的时候会重点讲的。

说到这大家可能感觉我有点啰嗦，哪有这么多道理，上来就干就完事了。别急，我说的这些在下面的代码讲解中都有身影。

那么我们先来看看递归法的代码应该怎么写。

递归法

递归三部曲

1. 确定递归函数的参数和返回值
   因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。返回值自然是bool类型。

代码如下：

func compare(left,right *TreeNode) bool {}

2. 确定终止条件
   要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。

• 节点为空的情况有：（注意我们比较的其实不是左孩子和右孩子，所以如下我称之为左节点右节点）

  • 左右都为空，对称，返回true
  • 左节点为空，右节点不为空，不对称，return false
  • 左不为空，右为空，不对称 return false

• 此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：

  • 左右都不为空，比较节点数值，不相同就return false
  • 此时左右节点不为空，且数值也不相同的情况我们也处理了。

代码如下：

	if left == nil && right == nil {
        return true
    }

    if left == nil || right == nil {
        return false
    }

    if left.Val != right.Val {
        return false
    }

3. 确定单层递归的逻辑
   此时才进入单层递归的逻辑，单层递归的逻辑就是处理 左右节点都不为空，且数值相同的情况。

• 比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
• 比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。
• 如果左右都对称就返回true ，有一侧不对称就返回false 。

代码如下：

  outside := compare(left.Left,right.Right)  // 左子树：左、 右子树：右
  inside := compare(left.Right,right.Left)   // 左子树：右、 右子树：左
  isSame := outside && inside  // 左子树：中、 右子树：中（逻辑处理）
  reutrn isSame

如上代码中，我们可以看出使用的遍历方式，左子树左右中，右子树右左中，所以我把这个遍历顺序也称之为“后序遍历”（尽管不是严格的后序遍历）。

最后递归的Go整体代码如下：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSymmetric(root *TreeNode) bool {
    // 根节点的左孩子的左孩子和根节点的右孩子的右孩子相等
    // 根节点的右孩子的左孩子和根节点的左孩子的右孩子相等
    if root == nil {
        return true
    }

    
    return compare(root,root)
}

func compare(left,right *TreeNode) bool {
    if left == nil && right == nil {
        return true
    }
	// 通过了上面的if后，如果下面这个if成立，则一定是一空一不空，两个节点不可能值相等
    if left == nil || right == nil {
        return false
    }

    if left.Val != right.Val {
        return false
    }

   outside := compare(left.Left,right.Right)  // 左子树：左、 右子树：右
   inside := compare(left.Right,right.Left)   // 左子树：右、 右子树：左
   isSame := outside && inside  // 左子树：中、 右子树：中（逻辑处理）
   
   reutrn isSame

}

我给出的代码并不简洁，但是把每一步判断的逻辑都清楚的描绘出来了。

如果上来就看网上各种简洁的代码，看起来真的很简单，但是很多逻辑都掩盖掉了，而题解可能也没有把掩盖掉的逻辑说清楚。

盲目的照着抄，结果就是：发现这是一道“简单题”，稀里糊涂的就过了，但是真正的每一步判断逻辑未必想到清楚。

当然我可以把如上代码整理如下：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSymmetric(root *TreeNode) bool {
    // 根节点的左孩子的左孩子和根节点的右孩子的右孩子相等
    // 根节点的右孩子的左孩子和根节点的左孩子的右孩子相等
    if root == nil {
        return true
    }

    
    return compare(root,root)
}

func compare(left,right *TreeNode) bool {
    if left == nil && right == nil {
        return true
    }

    if left == nil || right == nil {
        return false
    }

    if left.Val != right.Val {
        return false
    }

    return compare(left.Left,right.Right) && compare(left.Right,right.Left)

}

这个代码就很简洁了，但隐藏了很多逻辑，条理不清晰，而且递归三部曲，在这里完全体现不出来。

所以建议大家做题的时候，一定要想清楚逻辑，每一步做什么。把题目所有情况想到位，相应的代码写出来之后，再去追求简洁代码的效果。

迭代法

这道题目我们也可以使用迭代法，但要注意，这里的迭代法可不是前中后序的迭代写法，因为本题的本质是判断两个树是否是相互翻转的，其实已经不是所谓二叉树遍历的前中后序的关系了。

这里我们可以使用队列来比较两个树（根节点的左右子树）是否相互翻转，（注意这不是层序遍历）

使用队列
通过队列来判断根节点的左子树和右子树的内侧和外侧是否相等。

如下的条件判断和递归的逻辑是一样的。

Go代码如下：

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSymmetric(root *TreeNode) bool {
    // 根节点的左孩子的左孩子和根节点的右孩子的右孩子相等
    // 根节点的右孩子的左孩子和根节点的左孩子的右孩子相等
    // 迭代法：把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较
    if root == nil {
        return true
    }
    queue := make([]*TreeNode,0)
    queue = append(queue,root)
    queue = append(queue,root)

    for len(queue) > 0 {
        node1 := queue[0]
        node2 := queue[1]
        queue = queue[2:]
        if node1 == nil && node2 == nil {
            continue
        }
        // 一个空一个非空
        if node1 == nil || node2 == nil {
            return false
        }
        if node1.Val != node2.Val {
            return false
        }
        queue = append(queue,node1.Left)
        queue = append(queue,node2.Right)
        queue = append(queue,node1.Right)
        queue = append(queue,node2.Left)
    }

    
    return true
}

func compare(left,right *TreeNode) bool {
    if left == nil && right == nil {
        return true
    }

    if left == nil || right == nil {
        return false
    }

    if left.Val != right.Val {
        return false
    }

    return compare(left.Left,right.Right) && compare(left.Right,right.Left)

}

使用栈

细心的话，其实可以发现，这个迭代法，其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的。

只要把队列原封不动的改成栈就可以了

小结

这次我们又深度剖析了一道二叉树的“简单题”，大家会发现，真正的把题目搞清楚其实并不简单，leetcode上accept了和真正掌握了还是有距离的。

我们介绍了递归法和迭代法，递归依然通过递归三部曲来解决了这道题目，如果只看精简的代码根本看不出来递归三部曲是如何解题的。

在迭代法中我们使用了队列，需要注意的是这不是层序遍历，而且仅仅通过一个容器来成对的存放我们要比较的元素，知道这一本质之后就发现，用队列，用栈，甚至用数组，都是可以的。

如果已经做过这道题目的同学，读完文章可以再去看看这道题目，思考一下，会有不一样的发现！

相关题目推荐

这两道题目基本和本题是一样的，只要稍加修改就可以AC。

100.相同的树

100. 相同的树

给你两棵二叉树的根节点p和q，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：

输入：p = [1,2,3], q = [1,2,3]
输出：true

示例 2：

输入：p = [1,2], q = [1,null,2]
输出：false

示例 3：

输入：p = [1,2,1], q = [1,1,2]
输出：false
 

提示：

• 两棵树上的节点数目都在范围 [0, 100] 内
• -10^4 <= Node.val <= 10^4

Go代码

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSameTree(p *TreeNode, q *TreeNode) bool {
    // 同时前序遍历两棵树，每个对应位置的值相等即可
    if p == nil && q == nil {
        return true
    }
    if p == nil || q == nil {
        return false
    }

    if p.Val != q.Val {
        return false
    }

    return isSameTree(p.Left,q.Left) && isSameTree(p.Right,q.Right)
    // // 等价如下写法
    // left := isSameTree(p.Left,q.Left)
    // right := isSameTree(p.Right,q.Right)
    // return left && right
}

572.另一个树的子树

572. 另一棵树的子树

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

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

示例 1：

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

示例 2：

输入：root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
输出：false

提示：

• root 树上的节点数量范围是 [1, 2000]
• subRoot 树上的节点数量范围是 [1, 1000]
• -10^4 <= root.val <= 10^4
• -10^4 <= subRoot.val <= 10^4

Go代码

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func isSubtree(root *TreeNode, subRoot *TreeNode) bool {
    // 和第100题思路基本一致，以主树的每个节点作为子树根节点和题目给定的子树比较是否完全相等
    if root == nil && subRoot == nil {
        return true
    }
    if root == nil || subRoot == nil {
        return false
    }

    // 前序遍历，以主树的每个节点作为子树根节点
    if isSameTree(root,subRoot){  // 根
        return true
    }
    
    return isSubtree(root.Left,subRoot) || isSubtree(root.Right,subRoot)
    // // 等价
    // left := isSubtree(root.Left,subRoot) // 左
    // right := isSubtree(root.Right,subRoot) // 右
    // reutn left || right
}

func isSameTree(node1 ,node2 *TreeNode) bool {
    if node1 == nil && node2 == nil {
        return true
    }
    if node1 == nil || node2 == nil {
        return false
    }
    if node1.Val != node2.Val {
        return false
    }

    return isSameTree(node1.Left,node2.Left) && isSameTree(node1.Right,node2.Right)
}