leetcode每日刷题

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum

思路1：
两个for循环，第一个循环 I遍历数组，第二个循环找到target - I 时间复杂度 N^2
思路2：
利用集合，一个循环 I遍历数组 ，查看target - I 是否在集合中，若在集合中，则返回集合中元素对应下标和 I 元素对应的下标。
思路3：
利用一个dict（字典），一次循环 i， num分别记录原数组的下标和值。temp记录 target - 当前num
若 temp在字典中，则返回 [d[temp], i].

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        d = {}
        for i, num in enumerate(nums):
        	temp = target - num
        	if temp in d:
        		return [d[temp],i]
        	d[num] = i
        return []
        	

按奇偶排序数组

给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。

你可以返回满足此条件的任何数组作为答案。

示例：

输入：[3,1,2,4]
输出：[2,4,3,1]
输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-array-by-parity

思想1：遍历数组，将其中奇数存在新建数组 B 中，将 偶数存在 新建数组
C中，返回C+B即可。空间复杂度O（n）时间复杂度O（n）
思想2：用两个指针，指针odd 从数组头部开始找奇数，指针even 从数组尾部（len（A）- 1）开始找偶数。找到即交换。直到odd >= even.

下面展示一些 内联代码片。

class Solution(object):
    def sortArrayByParity(self, A):
        """
        :type A: List[int]
        :rtype: List[int]
        """
        i, j = 0, len(A) - 1
        while i <= j:
            # 找奇数
            while A[i] % 2 == 0 and i <= j:
                i += 1
            # 找偶数
            while A[j] % 2 != 0 and i <= j:
                j -= 1
            if i >= j:
                break
            A[i], A[j] = A[j], A[i]

搜索二维矩阵II

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。
示例:

现有矩阵 matrix 如下：

[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]

给定 target = 5，返回 true。
给定 target = 20，返回 false
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/search-a-2d-matrix-ii

思路1：用两个for循环遍历矩阵。时间复杂度O（nm)
思路2：由于数组每行都有序，对每一行都使用二分法。时间复杂度为O（m logn）
思路3：由数组性质，可以从右上开始搜索，若找到，则返回True，若数组内值val < target 则向前搜索。反之，则向下搜索。

        if not matrix:
            return False
        row = len(matrix)
        col = len(matrix[0])
        i = 0
        j = col - 1
        while i < row and j >= 0:
            val = matrix[i][j]
            if val == target:
                return True
            elif val < target:
                i += 1
            else:
                j -= 1
        return False

如何初始化二维数组

可以看到，如果直接用

l1 = [[0] * 3] * 3

这样初始化二维数组时，每一个列向量都是 Object的复制，这样会导致在复制操作时同时改变列上的元素
所以正确的初始化方法应该是：

l2 = [[0] * 3 for _ in range (3)]

移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。

你不需要考虑数组中超出新长度后面的元素。
示例 2:

给定 nums = [0,1,2,2,3,0,4,2], val = 2,

函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

注意这五个元素可为任意顺序。

你不需要考虑数组中超出新长度后面的元素。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-element

思想1：

既然是移除元素，那么可以直接将 值为val的元素 pop出去。

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        i = 0
        while i < len(nums):
            if nums[i] == val and i < len(nums):
                nums.pop(i)
                i -= 1
            i += 1
        return len(nums)

思想2：采用前后两个指针 i，j 前指针 i 用来寻找 等于 val的元素，后指针 j用来寻找不等于 val的元素。找到了则交换。这样可以保证数组的前i个元素的值均不为val

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        if not nums:
            return 0
        i = 0
        j = len(nums) - 1

        while i <= j:
            if nums[i] != val and i <= j :
                i += 1
            elif nums[j] == val and i <= j:
                j -= 1
            else:
                nums[i], nums[j] = nums[j], nums[i]
        return i

合并两个有序数组

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。

说明:

初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3

输出: [1,2,2,3,5,6]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-sorted-array

思想：

思想1：直接将两个数组相加后排序。时间复杂度为O((n+m)log(n+m))

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        nums1[:] = sorted(nums1[:m] + nums2)

思想2：
由于两个数组是有序的。可以从后端比较两个数组的元素。将大的放在nums1的最后面的位置。然后被赋值的那个指针前移。

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) 
        a = m - 1
        b = n - 1
        c = (n + m) - 1
        while a >= 0 and b >= 0:
            if nums1[a] <= nums2[b]:
                nums1[c] = nums2[b]
                b -= 1
            elif nums1[a] > nums2[b]:
                nums1[c] = nums1[a]
                a -= 1
            c -= 1
        nums1[:b + 1] = nums2[:b + 1]