【leetcode-Python】-Tree-101. Symmetric Tree

题目链接

https://leetcode.com/problems/symmetric-tree/

题目描述

给定二叉树，判断这棵二叉树是否是对称二叉树，即树的结构是否镜像对称的。

示例

二叉树[1,2,2,3,4,4,3]是镜像对称的，返回True：

    1
   / \
  2   2
 / \ / \
3  4 4  3

二叉树[1,2,2,null,3,null,3]不是镜像对称的，返回False:

    1
   / \
  2   2
   \   \
   3    3

解决思路一

一棵二叉树如果为镜像对称树，那么它的两棵左右子树成镜像对称。因此可以将问题拆解为：判断两棵树是否成镜像对称。

经过观察，我们会发现，如果两棵二叉树A、B成镜像对称，那么它们根节点的数值要相同，同时左右子树需要满足：A的左子树和B的右子树成镜像对称，A的右子树和B的左子树成镜像对称。因此问题进一步被拆解。如下图所示：

第一种方法是用递归的思想解决问题。

之前有总结过，写递归函数要想清楚三个问题：
1、函数的功能，这个函数是干什么的。

2、递归的结束条件，在参数是多少的情况下能够不再需要递归，能够直接计算并return结果。

3、在递归过程中，参数不断缩小的形式以及如何根据下一层递归结果得到当前递归层结果。

对于这三个问题，设计的递归函数的任务是判断两棵二叉树是否成镜像对称。递归的结束条件为：
两棵二叉树都为空（成镜像对称，返回True）；

只有一棵二叉树为空（不成镜像对称，返回False）；

两棵二叉树A B是否成镜像对称可以由条件句 (A.val == B.val)&&(A.leftsubtree和B.rightsubtree成镜像对称)&& (A.rightsubtree和B.leftsubtree成镜像对称)来判断。

解决思路一Python实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isMirror(self,l,r):
        if (l == None and r == None):
            return True
        if(l == None or r == None):
            return False
        return (l.val == r.val) and self.isMirror(l.left,r.right) and self.isMirror(l.right,r.left)
    def isSymmetric(self, root: TreeNode) -> bool:
        if root == None:
            return True
        return self.isMirror(root.left,root.right)

时间复杂度和空间复杂度

由于会遍历到树中的每个节点，时间复杂度为O(n),n为树中的节点个数。

最好情况下空间复杂度为O(log(n)),在最差的情况下，二叉树会退化成线性链表，此时二叉树高度为树中节点个数n，空间复杂度为O(n)。

此外，在官方题解里给的解决方案中，isSymmetric()函数体是这样的：

def isSymmetric(self, root: TreeNode) -> bool:
        return self.isMirror(root,root)

这种情况在第一层递归中self.isMirror(root.left,root.right)和self.isMirror(root.right,root.left)都会执行，但这两个函数的作用是一样的，因此会造成重复。（虽然时间复杂度不变，但是会拉长判断时间）

解决思路二

第二种方法利用了迭代的思想，逐个判断树中对应元素是否相等。数据结构使用栈或队列。

结合python内部数据结构的特征，用List能够实现栈的效果：

list.append(value):在列表末端添加元素；

list.pop():从列表末端移除元素，返回被移除的元素。

 将需要比较值是否相等的两个节点放到一个元组tuple里，然后加入stack，并逐个弹出比较。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        if root == None:
            return True
        stack = [(root.left,root.right)]
        while(len(stack)!=0):
            l,r = stack.pop()
            if (l == None and r == None):
                continue
            if(l == None or r == None):
                return False
            if(l.val != r.val):
                return False
            stack.append((l.left,r.right))
            stack.append((l.right,r.left))
        return True
    
        

时间复杂度和空间复杂度

由于每个节点仅被访问一次，时间复杂度为O(n), n为树中节点个数。

最好情况下空间复杂度为O(log(n)),最差情况下空间复杂度为O(n)。

其他

顺便补一句，List也能实现队列的效果，但是效率不高：list.insert(index,obj),设置index为0，则实现在list开头位置插入元素，但是每执行一次需要把列表中所有元素都向后移一个位置，时间复杂度为O(n)。

deque（double-ended-queue，发音为“deck”）是collections模块中的双端队列结构，在两端都可以操作，具有队列和栈的性质，从两个方向添加和删除元素的开销大概为O（1）。deque常用的几种使用场景如下：

from collections import deque
d = deque()
# deque实现栈操作
d.append(1) #将一个元素加入栈
d.append(2)
d.append(3) #deque([1,2,3])
x = d.pop() #弹出栈,x为返回的弹出元素,如果d为空触发IndexError deque([1,2])

#deque实现队列操作
d.appendleft(0)#deque([0,1,2])
x = d.popleft()#弹出队列，x为返回的弹出元素,如果d为空触发IndexError deque([1,2])

#extend用于将所有元素依次从尾部加入deque，append是将一个元素加入deque
d.append([1,2,3]) #deque([1,2,[1,2,3]])
d.pop()#deque([1,2])
d.extend([4,5,6]) #deque([1,2,4,5,6])

#extendleft用于将所有元素依次从头部加入deque（可以理解为iterable参数中的元素顺序倒过来一起加入deque双向队列的头部）
#extend和extendleft的参数是iterable类型，extend(iterable) extendleft(iterable)
d.extendleft('abc')#deque(['c', 'b', 'a', 1, 2, 4, 5, 6])

#rotate(n),n为正数时表示向右循环移动n步
#循环移动n步：假定共有m个整数，则要使前面m-n个数顺序向后移n个位置，并使最后n个数放到最前面。
d.rotate(2)#deque([5, 6, 'c', 'b', 'a', 1, 2, 4]) 向右循环移动2步：将最后面两个元素放到最前面。
d.rotate(-3) #deque(['b', 'a', 1, 2, 4, 5, 6, 'c']) 向左循环移动3步：将最前面3个元素放到最后面。

#计数
d.count(1)
#删除元素
d.remove(1) #deque(['b', 'a', 2, 4, 5, 6, 'c']) remove(value):移除找到的第一个value，如果没有的话就引发 ValueError。

d.reverse() #返回None，将d逆序 deque(['c', 6, 5, 4, 2, 'a', 'b'])

参考：

https://docs.python.org/zh-cn/3/library/collections.html?highlight=deque#collections.deque