【leetcode-python刷题】双指针(快慢指针)

141. 环形链表(easy)

题目

给定一个链表，判断链表中是否有环。

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

如果链表中存在环，则返回 true 。 否则，返回 false 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/linked-list-cycle
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

V1（快慢指针）

使用快慢指针，慢指针每次向后移动一个位置，快指针每次向后移动两个位置，如果存在环的话一定存在快慢指针相等的时候。
这种情况下算法的空间复杂度为O(1)，只使用了两个指针的额外空间。时间复杂度为O(N)，其中 N 是链表中的节点数。

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        if not head or not head.next:
            return False
        slow, fast = head, head.next
        while slow != fast:
            if not fast or not fast.next:
                return False
            slow = slow.next
            fast = fast.next.next
        return True

结果：

出错的地方：

1. 原本没有加第3、4行判断条件，报错：
   
   注意：not head 和 not head.next两个判断条件都需要，前者为了防止出现空链表的情况，后者为了在非空链表的前提下防止出现只有一个元素且不包含环的链表的情况。
2. 原本第7行的判断条件为 if not fast，缺少后面一个判断条件，报错：
   

在本地编写并测试时的代码：

# 定义结点
class Node(object):
    def __init__(self, item):
        self.item = item
        self.next = None

# 定义单链表
class SingleLinkList(object):
    def __init__(self):
        self._head = None  # 首地址指针head

def hasCycle(head):
    if not head or not head.next:
        return False
    slow, fast = head, head.next
    while slow != fast:
        if not fast or not fast.next:
            return False
        slow = slow.next
        fast = fast.next.next
    return True

link_list = SingleLinkList()
node1 = Node(3)
node2 = Node(2)
node3 = Node(0)
node4 = Node(-4)
link_list._head = node1
node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node2
print(hasCycle(node1))

V2（哈希表）

把见过的元素都放入seen集合，判断下一个元素是否出现在seen中。

def hasCycle(head):
    seen = set()
    while head:
        if head not in :
            seen.add(headseen)
            head = head.next
        else:
            return True
    return False

结果：

• 时间复杂度：O(N)，其中 N 是链表中的节点数。最坏情况下我们需要遍历每个节点一次。
• 空间复杂度：O(N)，其中 N 是链表中的节点数。主要为哈希表的开销，最坏情况下我们需要将每个节点插入到哈希表中一次。

283. 移动零(easy)

题目

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

V1

两个指针 i、j ，i 用来找到0，j 用来找到 i 后第一个非0元素，然后交换位置。

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        i = 0
        while i < len(nums) - 1:
            if nums[i] == 0:
                break
            i += 1
        if i == len(nums) - 1:
            return nums
        while i < len(nums) - 1:
            j = i + 1
            while j < len(nums):
                if nums[j] != 0:
                    break
                j += 1
            if j == len(nums):
                break
            nums[i], nums[j] = nums[j], nums[i]
            i += 1
            while nums[i] != 0:
                i += 1
        return nums

结果：

可以看到非常耗时。

V2

同样是两个指针，一个从头顺序指下去，保证所指位置都是非零的，另一个用来找所有非零项。

class Solution(object):
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        i = j = 0
        while j < len(nums):
            if nums[j] != 0:
                nums[i], nums[j] = nums[j], nums[i]
                i += 1
            j += 1

结果：

27. 移除元素(easy)

题目

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

V1

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        i = 0
        while i < len(nums):
            if nums[i] == val:
                del nums[i]
            else:
                i += 1
        return len(nums)

结果：

V2

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        index = 0
        for i in nums:
            if i != val:
                nums[index] = i
                index += 1
        return index

结果：

V3

双指针。

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        i, j = 0, len(nums) # 注意j的初始值
        while i < j:
            if nums[i] == val:
                nums[i] = nums[j-1]
                j -= 1
            else:
                i += 1
        return i

结果：

26. 删除排序数组中的重复项(easy)

题目

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

V1

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if len(nums) <= 1:
            return len(nums)
        i, index = 1, 1
        while i < len(nums):
            if nums[i] not in nums[:index]:
                nums[index] = nums[i]
                index += 1
            i += 1
        return index

结果：

V2

看了别人的解答才发现，我读题的时候漏了一个关键信息：有序数组。

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

结果：

80. 删除排序数组中的重复项 II(medium)

题目

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 最多出现两次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

V1

自己写的没成，参考的题解里的。

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        i = 2
        for j in nums[2:]:
            if nums[i-2] != j:
                nums[i] = j
                i += 1
        return i

结果：

一开始总想着弄个count计算指针所指的值出现的次数，没有想到直接跟向前两个的值比较就好了。