一些力扣思路随记

题目1:移除元素

要求

给你一个数组 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。
你不需要考虑数组中超出新长度后面的元素。

思路（列表索引access，减小时间复杂度，但会牺牲空间复杂度）

  为了减小时间复杂度，采用列表索引遍历的方法，因为列表的索引access是最快速高效的，但是会牺牲一定的空间复杂度。
  首先进行列表遍历，找到val的索引，之后采用pop()方法，进行元素的删除。

代码如下：

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        length = len(nums)
        index_list=[]
        num = 0                  #定义一个次数标志位，用于减少列表长度
        for i in range(length):
            if nums[i]==val:
                index_list.append(i)
        #上面已经获得了所有的元素索引值
        for j in range(len(index_list)):
            nums.pop(index_list[j]-num)
            num+=1
        return len(nums)

结果如下：

题目2 二分查找

要求

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

思路（二分查找）

对于一个升序排列的数组，查找某一元素，可以使用二分查找的方式。

代码

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        #二分查找
        left = 0
        right = len(nums) - 1
        while left <= right:
            middle = left + (right-left)//2
            if nums[middle] > target:
                right = middle - 1
            elif nums[middle] <target:
                left = middle + 1
            else :
                return middle
        return -1

结果

题目3 环形链表

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

思路（快慢指针是否对撞）

对于环形链表的判断，可以采用快慢指针的方式，如果快慢指针对撞，则说明存在环形的链表。快指针比慢指针走快一步。

代码

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
      #采用快慢指针
      slow = head
      fast = head
      while fast and fast.next:
        fast = fast.next.next
        slow = slow.next
        if fast == slow:
          return True
      return False

结果

题目4 两数之和（采用哈希表搜索）

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

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

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

思路一（哈希表，空间换时间）

由于哈希表搜索是非常高效的，所以对于提高时间复杂度而言，可以采用哈希查找的方式。判断当前元素与哈希表中的哪个元素之和为target，如果找到就返回索引值，如果没找到，就将当前值加入哈希表，继续搜索。

代码

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        #采用哈希表完成搜索
        hash_table = {}
        for i in range(len(nums)):
            tmp = nums[i]
            diff = target - tmp
            if diff in hash_table:
                return hash_table[diff],i
            elif diff not in hash_table:
                hash_table[tmp]=i

思路二（采用暴力搜索的方法，但是时间复杂度变成了$O(n^2)$）