LeetCode101. 对称二叉树Golang版

LeetCode101. 对称二叉树Golang版

1. 问题描述

给定一个二叉树，检查它是否是镜像对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

2. 思路

本题需要同时遍历两棵树，一棵树的顺序是左右中，另一棵是右左中

2.1. 递归

递归三部曲：

1. 确定递归函数的参数和返回值
   func isSame(left *TreeNode, right *TreeNode) bool
2. 确定终止条件

	if left == nil && right != nil return false
	else if left != nil && right == nil return false
	else if left == nil && right == nil return true
	else if left.Val != right.Val return false 

也可以写成

	if left == nil && right = nil return true
	if root == nil || right == nil return false
	if left.Val != right.Val return false

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

	// 左子树：左右中		右子树：右左中
	outside := compare(left.Left, right.Right)
	inside := compare(left.Right, right.Left)
	isSame := outside && inside
	return isSame

3. 代码

3.1. 递归代码

/**
 * 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 isSameTree(root.Left,root.Right)
}

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
    }

    outSide := isSameTree(p.Left,q.Right)
    inSide := isSameTree(p.Right,q.Left)

    return outSide && inSide
}

3.2. 迭代代码

本题的本质是判断两个树是否相互反转，已经不是纯粹的前中后序的关系了

1. 使用队列来比较两个树是否相互翻转

/**
 * 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 := []*TreeNode{}
    queue = append(queue, root.Left)
    queue = append(queue, root.Right)

    for len(queue) > 0 {
        leftNode := queue[0]
        rightNode := queue[1]
        queue = queue[2:]
        if leftNode == nil && rightNode == nil {
            continue
        }
        if leftNode == nil || rightNode == nil {
            return false
        }
        if leftNode.Val != rightNode.Val {
            return false
        }
        queue = append(queue, leftNode.Left)
        queue = append(queue, rightNode.Right)
        queue = append(queue,leftNode.Right)
        queue = append(queue, rightNode.Left)
    }
    return true
}