leetcode-数组

纯属记录

1、1 两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

1、思路：双层循环，遍历每一个数和它后面的数，看你和是否为target

class Solution():
    def twosum(self,data,target):

        for i in range(len(data)):
            for j in range(i+1,len(data)):
                if data[i] + data[j] == target:
                    return [i,j]

        return []
a = Solution()
print(a.twosum([1,2,3,4],4))

2、代码思路：目标值减去列表中的值依次存入字典，同时寻找字典中有没有和num中相同的数，有返回下标

class Solution():
    def twosum(self,num,target):
        dict = {}
        n = len(num)
        for i in range(n):
            opnum = target - num[i]
            if num[i] not in dict.keys():
                dict[opnum] = i
            else:
                return dict[num[i]],i

a = Solution()
print(a.twosum([1,2,3,4,5],3))

2 、15 三数之和

题目：给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。

排序 + 双指针 ，一个数的负数等于另外两数之和。

1、算法思路：
1、对数组进行排序，创建一个列表用以存放结果，计算循环次数n。
2、循环first,如果 first和它前一个数first - 1相同，说明数重复，结束本次循环，进行下一次。
3、当前数的负数记为target,第二个指针指向third，即数组最后一个数。第二个指针指向first右边第一个数表示为second。
4、循环第二个数second，second若是等于second-1,说明重复，结束本次循环。
5、看target与second + third之间的关系。

class Solution:
    def threeSum(self, nums):
        nums.sort()
        ans = list()
        n = len(nums)
        for first in range(n):
            if first > 0 and nums[first] == nums[first-1]:
                continue
            target = -nums[first]
            third = n-1
            for second in range(first+1,n):
                if second > first+1 and nums[second] == nums[second-1]:
                    continue
                while second < third and nums[second] + nums[third] > target:
                    third -= 1
                if second == third:
                    break
                if nums[second] + nums[third] == target:
                    ans.append([nums[first],nums[second],nums[third]])

        return ans

a = Solution()
print(a.threeSum([-1,0,1,2,-1,-4,2]))

3、26 删除有序数组中的重复项

题目：给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
1、遍历（因为式有序数组，所以每次遍历两个相邻数）

class Solution:
    def removeDuplicates(self, nums):
        n = len(nums)
        i = 1
        while i < n:
            if nums[i] == nums[i-1]:
                del(nums[i])
            else:
                i += 1
        return i
a = Solution()
print(a.removeDuplicates ([1,2,2,3,3,5,6]))

2、双指针

class Solution:
    def removeDuplicates(self, nums):
        n = len(nums)
        i = 0
        j = 1
        while j < n:
            if nums[i] == nums[j]:
                j += 1
            else:
                i += 1
                nums[i] = nums[j]
        return i + 1
a = Solution()
print(a.removeDuplicates ([1,2,2,3,3,6]))

3、双指针（leetcode）

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if not nums:
            return 0
        
        n = len(nums)
        fast = slow = 1
        while fast < n:
            if nums[fast] != nums[fast - 1]:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        
        return slow

4、27 移除元素

1、双指针

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        n = len(nums)
        i = -1
        for j in range(n):
            if nums[j] == val:
                continue
            else:
                i += 1
                nums[i] = nums[j]
        return i+1
a = Solution()
print(a.removeDuplicates ([1,2,2,3,3,6],3))
        

2、左指针left,右指针right,遍历数组，若right ==val,就将nums[left] = nums[right]，left加一，最后返回left.若不等于，right+1.

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

5 、35搜索插入位置

二分法
程序过程：
1、计算数组长度，left指向第一个数的下标，right指向最后一个数的下标
2、判断target与最后一个数的大小，若大于则将target加到数组末尾
3、left<right,进行二分查找

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

a = Solution()
print(a.removeDuplicates ( [1,3,5,6,7], 7))