【Leetcode刷题笔记】数组

一、两数之和

【题号】1
【题目描述】
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
【常规解法】
一、暴力双循环
二、两遍哈希表
在第一遍对数组进行遍历时，按顺序存入哈希表。key为数组中的数值，value为该数值对应的下标。
在第二遍对数组进行遍历时，以（目标值-元素数值）查找是否有对应的key。若有，则输出数组遍历时元素数值对应的i、以及所找到key对应的value。
三、一遍哈希表
与方法二类似，不过在第一遍存入哈希表的过程中、同时进行key的查找。
【我的代码】

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(0,len(nums)):
            for j in range(i+1,len(nums)):
                if target==nums[i]+nums[j]:
                    return [i,j]

【执行情况】

【范例代码】

"""
两层暴力循环（list）
"""
def twoSum(nums, target):
    lens = len(nums)
    j=-1
    for i in range(lens):
        if (target - nums[i]) in nums:
            if (nums.count(target - nums[i]) == 1)&(target - nums[i] == nums[i]):#如果num2=num1,且nums中只出现了一次，说明找到是num1本身。
                continue
            else:
                j = nums.index(target - nums[i],i+1) #index(x,i+1)是从num1后的序列后找num2                
                break
    if j>0:
        return [i,j]
    else:
        return []
"""
两层暴力循环（单向）
"""
def twoSum(nums, target):
    lens = len(nums)
    j=-1
    for i in range(1,lens):
        temp = nums[:i]
        if (target - nums[i]) in temp:
            j = temp.index(target - nums[i])
            break
    if j>=0:
        return [j,i]
"""
两遍哈希表
"""
def twoSum(nums, target):
    hashmap={
   }
    for ind,num in enumerate(nums):
        hashmap[num] = ind
    for i,num in enumerate(nums):
        j = hashmap.get(target - num)
        if j is not None and i!=j:
            return [i,j]
"""
一遍哈希表
"""
def twoSum(nums, target):
    hashmap={
   }
    for i,num in enumerate(nums):
        if hashmap.get(target - num) is not None:
            return [i,hashmap.get(target - num)]
        hashmap[num] = i #这句不能放在if语句之前，解决list中有重复值或target-num=num的情况

作者：lao-la-rou-yue-jiao-yue-xiang
链接：https://leetcode-cn.com/problems/two-sum/solution/xiao-bai-pythonji-chong-jie-fa-by-lao-la-rou-yue-j/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

【分析】
一、双循环暴力解法
我能想到的就是这种方法。不过思路和方法都可以参考一下范例。
范例1中用的不是直接判断两个num加起来是否为target，而是根据已知的num去查找所需要的num2是否在数组中。由于这里的数组在python中用了List表示，所以可以使用num2 in nums和**nums.index(num2)**快速查到num2是否存在及其下标号。
在范例1的基础上，对于已知的num，不从整个Nums list中去寻找Num2，而是只从[0:i]、即num元素前的部分List中寻找。
二、哈希表
哈希表的查找速度很快，所以考虑利用哈希表。
“通过以空间换取速度的方式，我们可以将查找时间从 O(n)O(n) 降低到 O(1)O(1)。哈希表正是为此目的而构建的，它支持以 近似 恒定的时间进行快速查找。”
把nums中每一个元素及其下标，分别作为key和value存入哈希表，后通过在哈希表查找所需要的num2，获得num2对应的下标Value。
这里有两种方法，第一种是把入表和查找完全分开，比较好理解；第二种是一边入表，一边在已入表的元素中查找，更为高效。
这里要注意的是对于第一个方法，先入表再查找，会发生重复元素在入表时的下标覆盖；对于第二种方法，需要先查找、再入表，否则对于有重复元素的数组、会发生覆盖。

二、删除排序数组中的重复项

【题号】26
【题目描述】
给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 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。
你不需要考虑数组中超出新长度后面的元素。
【常规解法】
双指针法。
一个慢指针，一个快指针 。
将快指针指向元素与慢指针指向元素进行比较。若相同，快指针进入下一位，慢指针不操作。若不同，快指针指向内容覆盖慢指针的下一位，快慢指针各自进位。直到慢指针到达数组边界。
【我的代码】

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        #单指针逐次剔除法
        """
        i=1
        while(i<len(nums)):
            if nums[i]==nums[i-1]:
                del(nums[i])
                continue
            i=i+1
        return i
        """
        #双指针逐次覆盖法
        i=0                     #慢指针
        j=1                     #快指针
        lenNums=len(nums)
        if lenNums<=1:
            return lenNums
        while(j<lenNums):
            if  nums[i]!=nums[j]:
                i=i+1
                if j!=i:
                    nums[i]=nums[j]
            j=j+1
        lenNewNums=i+1
        nums=nums[0:lenNewNums]
        return lenNewNums

【执行情况】

【范例】

public int removeDuplicates(int[] nums) {
   
    if (nums.length == 0) return 0;
    int i = 0;
    for (int j = 1; j < nums.length; j++) {
   
        if (nums[j] != nums[i]) {
   
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

作者：LeetCode
链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/solution/shan-chu-pai-xu-shu-zu-zhong-de-zhong-fu-xiang-by-/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

【分析】
这道题我先用了比较普通的方法，遍历一遍元素，若该元素与上一元素相同，则剔除该元素。
参考范例的双指针法后，我又写了一个版本的代码。这个双指针法主要是两个指针，快指针遍历去检查元素，慢指针只有出现不相同的元素时才进位。

三、移除元素

【题号】27
【题目描述】
给你一个数组 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。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。
【常规解法】
方法一：双指针
i为慢指针，j为快指针。起始时均指向数组首端。
当nums[j]不为目标值时，将nums[j]的值赋给nums[i]，且i、j同时递增。
若nums[j]为目标值，则只有j递增。
最终返回的i即为移除元素后的数组长度。
方法二：双指针——改变数组顺序
i为慢指针，j为快指针。i起始指向数组末端，j指向首端。
当nums[j]不为目标值时，将nums[j]的值与nums[i]交换。i递减。
若nums[j]为目标值，i递增。
【我的代码】

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        i=0
        j=0
        
        while(j<len(nums)):
            if nums[j]!=val:
                nums[i]=nums[j]
                i=i+1
            j=j+1
        return i

【执行情况】

【范例代码】

#双指针——正向慢指针
public int removeElement(int[] nums, int val) {
   
    int i = 0;
    for (int j = 0; j < nums.length; j++) {
   
        if (nums[j] != val) {
   
            nums[i] = nums[j];
            i++;
        }
    }
    return i;
}
#双指针——反向慢指针
public int removeElement(int[] nums, int val) {
   
    int i = 0;
    int n = nums.length;
    while (i < n) {
   
        if (nums[i] == val) {
   
            nums[i] = nums[n - 1];
            // reduce array size by one
            n--;
        } else {
   
            i++;
        }
    }
    return n;
}

作者：LeetCode
链接：https://leetcode