（LeetCode）双指针

0. 总结

双指针是一个强大的trick，广泛应用在数组或链表结构的问题中，一般而言，它可以将问题的时间复杂度由O(n^2)降到O(n)，将问题的空间复杂度降到O(1)。

常见的用法：环形链表里使用快慢指针、数组里使用左右指针

1. 移动零

283. move-zeroes

class Solution(object):
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.

        聪明解法
            1. 两个指针，i指针迭代，j指针表示（从左往右）非零元素个数的索引，i遇到非零就复制给j
            即：把非0元素都往数组前面扔，数组后面都应该是0
            https://leetcode-cn.com/problems/move-zeroes/solution/dong-hua-yan-shi-283yi-dong-ling-by-wang_ni_ma/
            2. i不是扔，是交换
        """
        # j = 0
        # for i in xrange(len(nums)):
        #     if nums[i] != 0:
        #         nums[j] = nums[i]
        #         j += 1
        # for k in xrange(j, len(nums)):
        #     nums[k] = 0

        j = 0
        for i in range(len(nums)):
            if nums[i] != 0:
                nums[i], nums[j] = nums[j], nums[i]
                j += 1
                

2. 环形链表

141. linked-list-cycle

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def hasCycle(self, head):
        """
        :type head: ListNode
        :rtype: bool

        笨办法
            有环说明一个节点被指向了两次
            使用set存储节点索引
        
        聪明法
            节点被访问过，就把值改为True

            双指针，一个快指针、一个慢指针，总会相遇
        """
        if not head:
            return False
        
        slow, fast = head, head
        while slow and fast:
            slow = slow.next
            if fast.next:
                fast = fast.next.next
            else:
                return False
            if slow == fast:
                return True
        return False

3. 回文链表

234. palindrome-linked-list

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def isPalindrome(self, head):
        """
        :type head: ListNode
        :rtype: bool

        笨办法
            链表输出到数组，然后两个指针前后移动检测数组元素是否相等
            时间O(2N)，空间O(N)
        """
        if not head:
            False
        
        array = []
        node = head
        while node:
            array.append(node.val)
            node = node.next
        
        i, j = 0, len(array) - 1
        while i <= j:
            if array[i] != array[j]:
                return False
            i += 1
            j -= 1
        
        return True

4. 寻找重复数

287. find-the-duplicate-number

class Solution(object):
    def findDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: int

        笨办法
            暴力搜索
            哈希表, 统计元素出现次数, 大于1就返回
        
        聪明办法
            快慢指针法
            可以将数组表示成一个带环的图: https://pic.leetcode-cn.com/f9104ccbbd4e572a8a9d6b2e7e2f75084b91c045b48e1dfc65cee238460257a1-image.png
            快慢指针都从起始位置出发, 慢指针一次走1步, 快指针一次走2步, 直到相遇
            然后, 慢指针回到起始位置, 快指针在相遇位置, 两者同时一次走1步, 再次相遇的点即我们要的数
        """
        slow, fast = 0, 0
        while slow == fast == 0 or slow != fast:
            slow, fast = nums[slow], nums[nums[fast]]
        
        slow = 0
        while slow != fast:
            slow, fast = nums[slow], nums[fast]
        
        return slow

5. 盛最多水的容器

11. container-with-most-water

class Solution(object):
    def maxArea(self, height):
        """
        :type height: List[int]
        :rtype: int

        笨办法
            暴力搜索
        
        聪明办法
            双指针法
            左右指针分别表示容器的左右边界, 初始值分别为样本的左右边界
            当左指针小于右指针时, 左指针右移; 否则, 右指针左移
            每次移动时, 计算当前面积, 直到左右指针相遇, 即可得最大面积
            https://leetcode-cn.com/problems/container-with-most-water/solution/sheng-zui-duo-shui-de-rong-qi-by-leetcode-solution/
        """
        max_area = 0
        left, right = 0, len(height) - 1

        while left < right:
            area = (right - left) * min(height[left], height[right])
            max_area = max(max_area, area)
            if height[left] < height[right]:
                left += 1
            else:
                right -= 1
        
        return max_area

6. 相交链表

160. intersection-of-two-linked-lists

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode

        笨办法
            固定A的某个节点，遍历B的所有节点，相等返回；
            遍历A的所有节点执行上面操作；
        
        聪明办法
        	构造环形链表
            A、B同时开始往后走；
            A走完了走B；B走完了走A；
            若相遇则返回，否则不相交；
        """
        pA, pB = headA, headB
        is_pa_linked, is_pb_linked = False, False
        while pA and pB:
            if pA == pB:
                return pA
            pA, pB= pA.next, pB.next
            if not pA and not is_pa_linked:
                pA = headB
                is_pa_linked = True
            if not pB and not is_pb_linked:
                pB = headA
                is_pb_linked = True
        return None
        

7. 无重复字符的最长子串

longest-substring-without-repeating-characters

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int

        笨办法：
            暴力解法

        聪明办法：
            滑动窗口，两个指针分别指向子串起始位置和结束位置
        """
        max_sub_len = 0
        tmp_set = set()
        i, j = 0, 0
        while j < len(s):
            while j < len(s) and s[j] not in tmp_set:  # j指针向后，直到遇到重复元素
                tmp_set.add(s[j])
                j += 1
            else:  # 遇到重复元素，输出以i为起始的最大子串，i后移一位，删除set中的上个i元素
                max_sub_len = max(max_sub_len, j - i)
                tmp_set.remove(s[i])
                i += 1
        return max_sub_len