【2021/4/15 刷题笔记】Leetcode之容易等级题

# 2021/4/15

目录

对称二叉树

【题目】

【我的方法】

执行结果：

【其他方法】

执行结果：

两个数组的交集 II

【题目】

【我的方法】

执行结果：

---

 

对称二叉树

【题目】

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

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

    1
   / \
  2   2
 / \ / \
3  4 4  3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3
进阶：

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

【我的方法】

递归：

1、如果root为null，返回True

2、如果root仅无左节点或者仅无右节点，返回False

3、递归比较root.left和root.right是否镜像，以及root.right和root.left是否镜像。

# 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:
        def func(root1,root2):
            if not root1 and not root2:
                return True
            elif not root1 and root2:
                return False
            elif not root2 and root1:
                return False
            elif root1.val != root2.val:
                return False
            else:
                return func(root1.left, root2.right) and func(root1.right, root2.left)
        if not root:
            return True
        return func(root.left, root.right)

执行结果：

执行用时：44 ms, 在所有 Python3 提交中击败了58.65%的用户

内存消耗：15.1 MB, 在所有 Python3 提交中击败了31.82%的用户

【其他方法】

@CeliaL3 的评论：

迭代：其实就是层序遍历，然后检查每一层是不是回文数组

# 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 not root:
            return True
        queue = [root.left,root.right]
        while(queue):
            next_que = list()
            layer = list()
            for node in queue:
                if not node:
                    layer.append(None)
                    continue
                next_que.append(node.left)
                next_que.append(node.right)
                layer.append(node.val)
            if layer!=layer[::-1]:
                return False
            queue = next_que
            
        return True

执行结果：

执行用时：40 ms, 在所有 Python3 提交中击败了81.90%的用户

内存消耗：15.1 MB, 在所有 Python3 提交中击败了24.81%的用户

 

---

两个数组的交集 II

【题目】

给定两个数组，编写一个函数来计算它们的交集。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2,2]
示例 2:

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[4,9]
说明：

输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。
我们可以不考虑输出结果的顺序。
进阶：

如果给定的数组已经排好序呢？你将如何优化你的算法？
如果 nums1 的大小比 nums2 小很多，哪种方法更优？
如果 nums2 的元素存储在磁盘上，内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

【我的方法】

1、先排序；

2、便利两个数组，如果相等则加入res，如果nums1[i]小，则 i 增加，否则 j 增加。

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        if not nums1 or not nums2:
            return []
        nums1.sort()
        nums2.sort()
        i = 0
        j = 0
        res = []
        while(i<len(nums1) and j<len(nums2)):
            if nums1[i]==nums2[j]:
                res.append(nums1[i])
                i += 1
                j += 1
            elif nums1[i]<nums2[j]:
                i += 1
            else:
                j += 1
        return res

执行结果：

执行用时：48 ms, 在所有 Python3 提交中击败了80.94%的用户

内存消耗：14.8 MB, 在所有 Python3 提交中击败了85.64%的用户