数据结构之双指针问题（二）

数组：有没有排序；有没有重复；有没有负数

双指针回顾----à

链表：查找中间节点、判断有无环、环的入口、链表中倒数第k个元素、归并排序、分区/快排、查找第k个最大元素

一、Merge Two Sorted Array into One

You are given two sorted arrays, A and B, and A has a large enough buffer at the end to hold B. Write a method to merge B into A in sorted order

def merge(nums1, m, nums2, n):
    while m > 0 and n > 0:
        if nums1[m-1] > nums2[n-1]:
            nums1[m+n-1] = nums1[m-1]
            m = m - 1
        else:
            nums1[m+n-1] = nums2[n-1]
            n = n - 1
    if n > 0:
        nums1[:n] = nums2[:n]
    return nums1
nums1 = [1, 2, 3, 0, 0, 0, 0]
m = 3
nums2 = [0, 2, 5, 6]
n = 4
print(merge(nums1, m, nums2, n))

 二、Minimum Difference Between Two Sorted Arrays

Given two arrays sorted in ascending order, find the absolute minimum difference between any pair of elements |a-b| such that a is from one array and b is from another array.

import sys
def printClosest(nums1, nums2):
    m = len(nums1)
    n = len(nums2)
    diff = sys.maxsize
    p1 = 0
    p2 = 0
    while p1 < m and p2 < n:
        if abs(nums1[p1]-nums2[p2]) < diff:
            diff = abs(nums1[p1] - nums2[p2])
        if nums1[p1] > nums2[p2]:
            p2 += 1
        else:
            p1 += 1
    return diff
nums1 = [1, 2, 3, 4, 5, 9, 10]
nums2 = [6, 7, 8, 10, 11]
print(printClosest(nums1, nums2))

 补充：两个有序数组的交集

如果是两个相差比较大的数组：从一个数组挨次取元素，去另一个数组二分查找。nlogm

如果是两个差不多大的数组：双指针 m+n

三、Continuous Maximum Subarray

Given an array having N positive integers, find the contiguous subarray having sum as great as possible, but not greater than M.

def continuousMax(nums, target): 
    i = j = 0
    res = resp = resq = 0
    while j < len(nums):
        sum = 0
        for k in range(i, j+1):
            sum += nums[k]
        if sum <= target:
            if res < sum:
                res = sum
                resp = i
                resq = j
            j += 1
        else:
            i += 1

    return (resp, resq)
nums = [4, 7, 12, 1, 2, 3, 6]
print(continuousMax(nums, 18))

from itertools import accumulate # O(n)
def max_subarray(nums, ceiling):
    cum_sum = [0]
    cum_sum = cum_sum + nums
    cum_sum = list(accumulate(cum_sum))
    l = 0
    r = 1
    maximum = 0
    while l < len(cum_sum):
        while r < len(cum_sum) and cum_sum[r] - cum_sum[l] <= ceiling:
            r += 1
        if cum_sum[r-1] - cum_sum[l] > maximum:
            maximum = cum_sum[r-1] - cum_sum[l]
            pos = (1, r-2)
        l += 1
    return pos

四、Majority Element

Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.

from collections import  Counter # O（n） 空O(n)
def majority(nums):
    dic = Counter()
    res = []
    for num in nums:
        if num in dic:
            dic[num] += 1
        else:
            dic[num] = 1
    for key, values in dic.items():
        if dic[key] >= len(nums) // 2:
            res.append(key)
    return res
nums = [1, 2, 3, 4, 6, 6, 6, 6, 6]
print(majority(nums))

排序：O(nlogn)  O(1)

# Boyer-Moore Voting Algorithm
# O(n) O(1)
def majority(nums):
    result = count = 0
    for i in nums:
        if count == 0:
            result = i
            count += 1
        elif result == i:
            count += 1
        else:
            count -= 1
    return result

进阶:

Given an integer array of size n, find all elements that appear more than ⌊ n/3 ⌋ times.

字典/排序

摩尔：刚才给一个candidate，现在给两个candidate。

# 摩尔投票算法

def majority(nums):
    result = count = 0
    for i in nums:
        if count == 0:
            result = i
            count += 1
        elif result == i:
            count += 1
        else:
            count -= 1
    return result
def majority1(nums):
    n1 = n2 = None
    c1 = c2 = 0
    for num in nums:
        if n1 == num:
            c1 += 1
        elif n2 == num:
            c2 += 1
        elif c1 == 0:
            n1 = num
            c1 = 1
        elif c2 == 0:
            n2 = num
            c2 = 1
        else:
            c1 -= 1
            c2 -= 1
    size = len(nums)
    return [n for n in (n1, n2)
            if n is not None and nums.count(n) > size / 3]
print(majority1([1, 1, 1, 1, 1, 0, 2, 3, 4, 5, 6, 7, 8, 9]))

五、Sort Color

荷兰国旗

Given an array with n objects colored red, white or blue, sort them so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

排序：nlogn

计数排序：n

# 计数排序-->有范围且有大量重复，O(n)
def countSort(nums):
    res = [[], [], []]
    for num in nums:
        if num == 0:
            res[0].append(num)
        elif num == 1:
            res[1].append(num)
        else:
            res[2].append(num)
    return res
def sortColors(nums):
    count = [0] * 3
    for num in nums:
        count[num] += 1
    i = 0
    for j in range(3):
        for _ in range(count[j]):
            nums[i] = j
            i += 1
    return nums
print(countSort([0, 0, 0, 1, 2, 2, 0, 1, 2, 0, 2, 1, 0, 1, 0]))
print(sortColors([0, 0, 0, 1, 2, 2, 0, 1, 2, 0, 2, 1, 0, 1, 0]))

def sortColors(nums): # l-->最后一个0的后面一个， i-->当前探索的点， r-->第一个2的前面一个
    i, l, r = 0, 0, len(nums) - 1
    while i <= r:
        if nums[i] == 0:
            nums[i], nums[l] = nums[l], nums[i]
            i, l = i + 1, l + 1
        elif nums[i] == 2:
            nums[i], nums[r] = nums[r], nums[i]
            r -= 1
        else:
            i += 1
    return nums

def sortColor(nums):
    l = 0 #最后一个0结尾的后面一个
    m = 1 #当前正在检测的点
    r = len(nums) - 1 #第一个2的前面一个
    while m < r:
        if nums[m] == 0:
            nums[l], nums[m] = nums[m], nums[l]
            l += 1
            if nums[l] == nums[m]:
                m += 1
        elif nums[m] == 2:
            nums[m], nums[r] = nums[r], nums[m]
            r -= 1
            if nums[m] == nums[r]:
                m -= 1
        else:
            m += 1
    return nums

print(sortColor([0, 0, 0, 1, 2, 2, 0, 1, 2, 0, 2, 1, 0, 1, 0]))
print(sortColors([0, 0, 0, 1, 2, 2, 0, 1, 2, 0, 2, 1, 0, 1, 0]))

六、Find K Closest Elements

Given a sorted array, two integers k and x, find the k closest elements to x in the array. The result should also be sorted in ascending order. If there is a tie, the smaller elements are always preferred.

排序：o(n)+O(nlogn)

heap：klogk + n

#双指针 
def findKClosest(nums, target):
    left = 0
    right = len(nums) - 1
    flag = False
    while left + 1 < right:
        mid = (left + right) // 2
        if nums[mid] > target:
            right = mid
        elif nums[mid] == target:
            flag = True
            break
        else:
            left = mid
    if not flag:
        mid = left if target - nums[left] <= nums[right] - target else right
    count = 1
    res = [nums[mid]]
    rmid = mid + 1
    lmid = mid - 1
    while count < 5:
        if nums[rmid] - target < target - nums[lmid]:
            res.append(nums[rmid])
            rmid += 1
            count += 1
        else:
            res.append(nums[lmid])
            lmid -= 1
            count += 1
    return res

内置的bisect！

import bisect
def findKClosestElements(nums, k, x):
    left = right = bisect.bisect_left(nums, x)
    if left == 0:
        return nums[:k]
    if right == len(nums):
        return nums[-k:]
    while right - left < k:
        if x - nums[left] <= nums[right] - x:
            left -= 1
        else:
            right += 1
    return nums[left:right]
num = [1, 20, 22, 23, 24, 25, 26]
print(findKClosestElements(num, 6, 19))

七、Container With Most Water

Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.

# brute force O(n**2)
def maxArea(height):
    res = 0
    for i in range(len(height)):
        for j in range(i+1, len(height)):
            res = max(res, min(height[i], height[j])*(j-i))
    return res

# 双指针
def maxArea(height):
    left = 0
    right = len(height) - 1
    res = 0
    while left < right:
        res = max(res, (right - left) * min(height[left], height[right]))
        if height[left] < height[right]:
            left += 1
        else:
            right -= 1
    return res

总结：

一个数组：需不需要sort-->如果要用双指针：都往后，往中间，都往前，往两边

两个数组：大多数是排好序的