菜鸟刷题——力扣167-26-27

题目一：167两数之和2-输入有序数组

解决方法

这里我想到了三种方法。

方法一：暴力求解法

使用两个for循环来依次遍历数组，将取到的两个数据之和与target相比较。但是这种方法时间复杂度高，在力扣上超出了运行时间限制。完整代码如下：

'''给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列  ，请你从数组中找出满足相加之和等于目标数 target 的两个数。
如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。
以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。
你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。
你所设计的解决方案必须只使用常量级的额外空间。'''
class Solution(object):
    def twoSum(self, number, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        '''方法一：暴力求解(超出时间限制)'''
        index1=1
        if (number[0] + number[1])>target:
            return
        for i in number[:]:
            index2 = index1+1
            for j in number[index1:]:
                if (i+j==target):
                    return [index1, index2]
                index2 = index2 + 1
            index1 = index1 + 1
        return       
if __name__ == '__main__':
    number = [5,15,25,75,85] # 2,7,11,15 2,3,4 5,25,75
    target = 100
    aa = Solution()
    result = aa.twoSum(number, target)
    a = 1

方法二：双指针法

该方法使用两个指针，一个left指针由前往后遍历，一个right指针由后往前遍历。如果两者之和小于target值，则将left指针往后移动一位；如果两者之和大于target值，则将right指针往前移动一位继续判断。完整代码如下：

'''给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列  ，请你从数组中找出满足相加之和等于目标数 target 的两个数。
如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。
以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。
你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。
你所设计的解决方案必须只使用常量级的额外空间。'''
class Solution(object):
    def twoSum(self, number, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        '''方法二：双指针法'''
        left = 0
        right = len(number) - 1
        while left<right:
            sum = number[left] + number[right]
            if sum == target :
                return[left+1, right+1]
            if sum < target:
                left += 1
            elif sum > target:
                right -= 1
        return
if __name__ == '__main__':
    number = [5,15,25,75,85] # 2,7,11,15 2,3,4 5,25,75
    target = 100
    aa = Solution()
    result = aa.twoSum(number, target)
    a = 1

该方法跟方法一相比大大减少了时间复杂度。

方法三：二分法

该方法我是看了别人写的题解，一开始还没转过来。因为我之前接触的二分法都是对left和right的指针所指向的值进行操作，但是该方法只是利用left和right来决定mid指针所指向的值。利用mid所指向的值与数组遍历的值之间的和target相比较。该方法其实跟暴力求解法一个思路，只不过把第二个for循环选取值的部分利用二分法做了优化。完整代码如下：

'''给你一个下标从 1 开始的整数数组 numbers ，该数组已按 非递减顺序排列  ，请你从数组中找出满足相加之和等于目标数 target 的两个数。
如果设这两个数分别是 numbers[index1] 和 numbers[index2] ，则 1 <= index1 < index2 <= numbers.length 。
以长度为 2 的整数数组 [index1, index2] 的形式返回这两个整数的下标 index1 和 index2。
你可以假设每个输入 只对应唯一的答案 ，而且你 不可以 重复使用相同的元素。
你所设计的解决方案必须只使用常量级的额外空间。'''
class Solution(object):
    def twoSum(self, number, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        '''方法三：二分法'''
        length = len(number)
        for i in range(length):
            left, right = i+1, length # 这里是为了防止mid等于i
            while left<right:
                mid = (right-left)//2 + left
                if number[i] + number[mid] == target:
                    return [i+1, mid+1]
                if number[i] + number[mid] < target:
                    left = mid + 1
                else:
                    right = mid
        return [-1, -1]
if __name__ == '__main__':
    number = [5,15,25,75,85] # 2,7,11,15 2,3,4 5,25,75
    target = 100
    aa = Solution()
    result = aa.twoSum(number, target)
    a = 1

题目二：26删除有序数组中的重复项

解决方法

这种题目最常见的解决方法即双指针法。在这里我们使用两个指针，p,q。p指针从数组的第一个元素开始遍历，q指针从数组的第二个元素开始遍历。当p指针与q指针相等时，我们固定住p指针，将q指针往后继续遍历；当q的值不等于p指针的值时，将q位置上的数组赋值给数组p+1位置。然后将p指针往后移动。完整代码如下：

'''给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。
元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。
考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。
nums 的其余元素与 nums 的大小不重要。
返回 k 。'''
class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        '''方法一：双指针'''
        p = 0
        q = 1
        count = 1
        length = len(nums)
        while(q<length):
            if nums[p]==nums[q]:
                q += 1
            else:
                p += 1
                nums[p] = nums[q]
                q +=1
                count +=1
        return count, nums
if __name__ == '__main__':
    nums = [0,0,1,1,1,2,2,3,3,4] # 0,0,1,1,1,2,2,3,3,4    1,1,2
    aa = Solution()
    count, list = aa.removeDuplicates(nums)
    a = 1

题目三：27移除元素

解决方法

该方法采用快慢指针。也就是双指针的思想。跟前两个的思路差不多，这里不做赘叙了。完整代码如下：

'''给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。'''
class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        '''方法一：快慢指针'''
        length = len(nums)
        fast = slow = 0
        while fast<length:
            if nums[fast]!=val:
                nums[slow] = nums[fast]
                fast += 1
                slow += 1
            else:
                fast += 1
        return slow, nums
if __name__ == '__main__':
    nums = [3,2,2,3] # 3,2,2,3    0,1,2,2,3,0,4,2
    val = 3
    aa = Solution()
    count, list = aa.removeElement(nums, val)
    a = 1

如果有更佳的方法来解决这个问题，非常欢迎大家分享！