对称二叉树python(leetcode101)

# 101. 对称二叉树 

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

1 递归

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def isSymmetric(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        # 递归
        # 比较的是两个子树的 内侧和外侧 结点是否相等
        # 深度优先搜索的话 一个是左右中 一个是右左中的遍历顺序
        if not root:
            return True
        return self.compare(root.left, root.right)

    def compare(self, left, right):
        # 对两个子树的根结点进行判断
        # 当子树的根结点存在None时
        
        if left == None and right != None:
            return False
        elif left != None and right == None:
            return False
        elif left == None and right ==None:
            return True
        
        # 当两个子树的根结点不为空时
        elif left.val != right.val:
            return False
        
        # 左子树的左结点与右子树的右节点
        out_ = self.compare(left.left, right.right)
        # 左子树的右结点与右子树的左节点
        in_ = self.compare(left.right, right.left)
        res = out_ and in_
        return (res)

2 迭代

分别使用队列和栈

# 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
from collections import deque
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        # 使用队列迭代
        if not root:
            return True
        # que = deque()
        # # 使用que进行pop两个结点再对比
        # que.append(root.left)
        # que.append(root.right)
        # while que:
        #     # 先比较左右树的子节点
        #     left_node = que.popleft()
        #     right_node = que.popleft()
        #     if not left_node and not right_node:
        #        # 左右结点都为空，判断下一对结点
        #        continue

        #     elif not left_node and right_node:
        #         return False
        #     elif left_node and not right_node:
        #         return False
              # 存在None的情况都判断了，剩下的是判断结点值存在的情况
        #     elif left_node.val != right_node.val:
        #         return False

            
        #     # 剩下的情况就是左右两个结点的值相等时
        #     que.append(left_node.left)
        #     que.append(right_node.right)
        #     que.append(left_node.right)
        #     que.append(right_node.left)
        # return True

        st = []
        # 使用stack进行pop两个结点再对比
        st.append(root.left)
        st.append(root.right)
        while st:
            # 先比较左右树的子节点
            right_node = st.pop()
            left_node = st.pop()
            if not left_node and not right_node:
               # 左右结点都为空，判断下一对结点
               # 判断左右结点都为空在最前
               continue
            
            elif not left_node and right_node:
                return False
            elif left_node and not right_node:
                return False
            # 存在None的情况都判断了，剩下的是判断结点值存在的情况
            elif left_node.val != right_node.val:
                return False

            
            # 剩下的情况就是左右两个结点的值相等时
            st.append(left_node.left)
            st.append(right_node.right)
            st.append(left_node.right)
            st.append(right_node.left)
        return True