LeetCode整理 - [Array篇]

持续更新中…

LeetCode-1: 两数之和(Two Sum) [Array-Easy]

题目：

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

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

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

解-Python-暴力遍历

class Solution():
    def twoSum(self, nums, target):
        for i in range(len(nums) - 1):
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] == target:
                    return (i,j)

解-Python-优:

class Solution2():
    def twoSum(self, nums, target):
        hash = {}
        for index, num in enumerate(nums):
            if target - num in hash:
                return hash[target-num], index
            hash[num] = index

解析：

1. python中dict是用hash表实现的，时间复杂度为O(1),选择用dict来存取
2. 使用python内置的enumerate来枚举出index-num对
3. 首先创建一个字典"hash"来存储nums中的值，存储方式是key=num, value=index
4. 算法是： 检查target-num是否在字典中，①如果不存在的话就把当前的num及其下标index存入字典中hash[num] = index， key是num， value是下标index ②存在的话就是找到了这两个数字，这两个数字分别是target-num和当前的num, 他们的下标分别是hash[target-num], index
5. 这里有两个细节：
   1. 先查询后插入，如果先插入后查询会有一个bug，当target=num*2会误判
   2. 因为hash[target-num]这个下标小，所以返回值是return hash[target-num], index， 而不是return index, hash[target-num]
6. 复杂度

   1. 时间复杂度：O(n)
      遍历一次包含 n 个元素的列表nums， 在hash table中查询，每次查询的时间复杂度 O(1)

   2. 空间复杂度：O(n)
      所需空间取决于哈希表中存储的元素数量，最多存储 n 个

LeetCode-26: 删除排序数组中的重复项(Remove Duplicates from Sorted Array) [Array-Easy]

题目：

给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。
示例 2:

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

函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

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

解-Python-优：

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if len(nums) == 0:
            return 0
        index = 0
        for i in range(1, len(nums)):
            if nums[i] != nums[index]:
                index += 1
                nums[index] = nums[i]
        return index + 1

解析：

1. 前提，给定的数组是有序的从小到大排列，如果两个元素不相等，那么后面的元素一定大于前面的元素
2. 数组要原地修改， 原地修改的意思就是修改原有的数组，不能创建新的数组。（一个数组在内存中创建后，对其修改不会改变它的内存地址）
3. 如果数组长度为0，直接返回0
4. 在原地修改，那么就是把新的数组的元素重新排列进行覆盖， 这里用一个index作为修改后的数组下标，初始值为0，指向数组的第一个位置
5. 从下标1开始对nums进行遍历，与nums[index]相比，第一次比较也就是比较nums中的第一个和第二个元素，如果不相等，也就是nums[1]比nums[0]大，那么index + 1（此时等于1），把nums[1]覆盖到index = 1的位置。如此往复循环，每当两个数字相等，什么都不做，每当发现大的数字，就把index + 1，并存上这个值
6. 返回index + 1就是新的长度， index从0开始的，所以+1

LeetCode-27: 移除元素(Remove Element) [Array-Easy]

题目：

给定一个数组 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。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。

解-Python-优：

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        index = 0
        for i in range(len(nums)):
            if nums[i] != val:
                nums[index] = nums[i]
                index += 1
        return index

解析：

1. 数组要原地修改， 原地修改的意思就是修改原有的数组，不能创建新的数组。（一个数组在内存中创建后，对其修改不会改变它的内存地址）
2. 用一个index来标识修改后的数组的下标， 初始值为0，指向数组的第一个位置
3. 对nums进行遍历，对每个num和目标val进行比较
   1. 如果不相同那就是要留下的，把值存在index的位置，并把index往后移一位
   2. 如果相同就是不要的，什么都不做，进入下一轮循环
4. 返回index就是新的长度

LeetCode-35: 搜索插入位置(Search Insert Position) [Array-Easy]

题目：

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5 输出: 2 示例 2:
输入: [1,3,5,6], 2 输出: 1 示例 3:
输入: [1,3,5,6], 7 输出: 4 示例 4:
输入: [1,3,5,6], 0 输出: 0

解-Python-遍历：

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        if target in nums:
            return nums.index(target)
        size = len(nums)
        if target > nums[-1]:
            return size
        index = 0
        for index in range(size):
            if nums[index] > target:
                nums.insert(index, target)
                return index

解析：

1. 根据大小排序，需要把目标值插入到数组中, 分两种情况，目标值存在和不存在与数组中
2. 首先如果存在，直接返回index， 如果target大于数组中最后一位数字，那就要插入到最后，size这个值正是插入的序号
3. 如果不存在就遍历nums，从头开始比对，一旦到比target大的位置，就在这个位置插入target，然后返回当前的index
4. 时间复杂度： O(n)， nums长度为n的时候，遍历的次数级数是n

解-Python-优(二分法)：

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        size = len(nums)
        if size == 0:
            return 0
        if nums[-1] < target:
            return size
        left = 0
        right = size -1
        while left < right:
            mid = left + (right - left) // 2
            if target <= nums[mid]:
                right = mid
            else:
                left = mid + 1
        return left

解析：

1. 上一种解法的时间复杂度为O(n)，可以改用二分法，将时间复杂度降为O(log2n)
2. 首先还是一样的，如果nums长度为0， 如果target大于数组中最后一位数字，那就要插入到最后，size这个值正是插入的序号
3. 然后这里为了代码简洁不去区分target是否存在（个人认为区分也行）
4. 利用二分法查询出目标位置，左边界left从0开始，右边界到size-1结束
5. 因为分局题目要求理解下来，target只要插入在第一个比它大的位置（target不在数组中），或者返回target的序号（target在数组中），也就是目标位置在第一次大于或者等于target的地方， 所以这里二分法需要注意右边界的更改，right=mid 而不是 right=mid-1， right=mid-1会导致target不在数组中的时候插入错误（位置前移了一位），如果前面第3点区分了情况，那么这里的细节可以不用考虑
6. 在这里最后返回的left,right都行, 关于二分法的边界 点击这里