LeetCode Python 刷题之路【数组篇】

持续更新中……

1.两数之和
给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。假设每个输入只对应一种答案，且同样的元素不能被重复利用。

举例：
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

思路：利用python中的字典记录下数组中每个元素的值和其对应的索引坐标，也就是其他语言中的哈希表、散列表。

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        dic = dict()   #建立一个空字典，也可以写成dic={}
        for index, value in enumerate(nums):
            sub = target - value
            if sub in dic:
                return [dic[sub], index]
            else:
                dic[value] = index #存储数组nums中的值和其对应的索引坐标

if __name__ == '__main__':
    nums = [2, 7, 11, 15]
    print(type(nums))
    target = 9
    result = Solution().twoSum(nums, target)
    print(result)

2.删除排序数组中的重复项
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在原地修改输入数组并在使用 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 = 0
        while i < len(nums) - 1:
            if nums[i] == nums[i + 1]:
                nums.remove(nums[i])
                #nums.pop(i)
            else:
                i += 1
        return len(nums)


if __name__ == '__main__':
    nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
    print(Solution().removeDuplicates((nums)))
    print(nums)

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。
注意这五个元素可为任意顺序。

思路：依据题目和例子，不能使用额外的数组。可以先进行数组遍历，记录重复元素的个数，在执行移除操作。

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        count=0
        for i in range(len(nums)):
            if nums[i]==val:
                count =count +1

        for j in range(count):
            nums.remove(val)

        return len(nums)

if __name__ == '__main__':
    nums = [0,1,2,2,3,0,4,2] #
    print(Solution().removeElement(nums,2))
    print(nums)

4.搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。你可以假设数组中无重复元素。

示例1：
输入: [1,3,5,6], 5
输出 2
示例2：
输入: [1,3,5,6], 2
输出: 1

思路：先搜索目标值在不在列表中，如果不在，先插入列表，然后再排序，最后返回目标值索引。

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        for i in range(len(nums)):

            if nums[i] == target:
                return i

            else:
                nums.append(target)
                nums.sort()
                return nums.index(target)

if __name__ == '__main__':
    nums = [2, 3, 4, 7,8,9]
    target =11
    print(Solution().searchInsert(nums,target))

5.最大子序和
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

class Solution():
    def maxSubArray(self, nums):
        for i in range(1,len(nums)):
            nums[i]=max(nums[i],nums[i]+nums[i-1])
        return max(nums)

if __name__ == '__main__':
    nums = [-2,1,-3,4,-1,2,1,-5,4]
    print(Solution().maxSubArray(nums),nums)

6.加一
给定一个非负整数组成的非空数组，在该数的基础上加一，返回一个新的数组。最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。你可以假设除了整数 0 之外，这个整数不会以零开头。

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

思路：这题只要注意三种数字组合，如：9、99、1299。
方法1：

class Solution(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        if digits[-1] == 9 and len(digits) == 1:
            digits[-1] = 0
            digits.insert(0, 1)
            return digits

        if digits[-1] != 9 or len(digits) == 1:
            digits[-1] = digits[-1] + 1
            return digits

        digits[-1] = 0
        i = 2
        while True:
            if digits[-i] == 9 and len(digits) > i:
                digits[-i] = 0
                i += 1
            elif digits[-i] == 9 and len(digits) == i:
                digits[-i] = 0
                digits.insert(0, 1)
                return digits
            else:
                digits[-i] += 1
                return digits


if __name__ == '__main__':
    # digits = [1,2,3,4]
    # digits = [1, 2, 9, 9]
    # digits = [9]
    digits = [9, 9]
    print(Solution().plusOne(digits))

方法2：列表转字符串，字符串转数字进行四则运算

class Solution(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        a=""
        for i in digits:
            a+=str(i)
        a=int(a) + 1
        b=[]
        for i in str(a):
            b.append(int(i))
        digits = b   
        return digits