数据结构之滑动窗口

双指针：在一个数组中同时从前往后走，一个快，一个慢

什么时候移动那个指针；找一个合法的窗口，怎么定义一个合法的窗口，什么时候打破，如何打破。

一、Remove Duplicates from Sorted Array

Given a sorted array, remove the duplicates such that each element appear only once and return the new length.

def remove_duplicate(nums):
    i, j = 0, 1
    while j < len(nums):
        if nums[i] != nums[j]:
            i += 1
            nums[i] = nums[j]
        j += 1
    return nums[:i+1]
def removeDuplicates(nums):
    if not nums:
        return 0
    tail = 0
    for j in range(1, len(nums)):
        if nums[tail] != nums[j]:
            tail += 1
            nums[tail] = nums[j]
    return nums[:tail+1]

进阶：重复数字最多出现两次

# 思路一：跟前面两个比
def removeDuplicates(nums):
    prev = 1
    cur = 2
    while cur < len(nums):
        if nums[prev - 1] == nums[prev] and nums[prev] == nums[cur]:
            cur += 1
        else:
            prev += 1
            nums[prev] = nums[cur]
            cur += 1
    return nums[:prev+1]
# 思路二：跟前面第二个元素比
def remove_Duplicates(nums):
    tail = 1
    cur = 2
    while cur < len(nums):
        if nums[cur] == nums[tail - 1]:
            cur += 1
        else:
            tail += 1
            nums[tail] = nums[cur]
            cur += 1
    return nums[:tail+1]
# 思路二的另一种写法：

def removeDuplicates(nums):
    count = 0
    for i in range(len(nums)):
        if count < 2 or nums[count - 2] != nums[i]:
            nums[count] = nums[i]
            count += 1
    return nums[:count]

二、Remove Element

Given an array nums and a value val, remove all instances of that value in-place and return the new length.

def removeElement(nums, val):
    i = 0
    j = 0
    while j < len(nums):
        if nums[j] == val:
            j += 1
        else:
            nums[i] = nums[j]#缺点：有很多多余的赋值操作
            j += 1
            i += 1
    return i

def removeElement2(nums, val):
    start, end = 0, 0
    while start <= end:
        if nums[start] == val:
            nums[start], nums[end] = nums[end], nums[start]
            end -= 1
        else:
            start += 1
    return start

三、Maximum Average Subarray

Given an array consisting of n integers, find the contiguous subarray of given length k that has the maximum average value. And you need to output the maximum average value

Assume 1 <= k <= n 

直接sum/slice,每次移动窗口都计算一次：O(kn)

可以用accumulate

def findMaxnumsaverage(nums, k):
    p = [0]
    for x in nums:
        p.append(p[-1] + x)
    moving_sum = max(p[i+k] - p[i] for i in range(len(nums)-k+1))
    return moving_sum / float(k)

from itertools import accumulate
def findMax(nums, k):
    t = [0]
    t.extend(nums)
    tmp = list(accumulate(t))
    moving_sum = max(tmp[i + k] - tmp[i] for i in range(len(nums) - k + 1))
    return moving_sum / float(k)

def find_max(nums, k):
    moving_sum = 0.0
    for i in range(k):
        moving_sum += nums[i]
    res = moving_sum
    for i in range(k, len(nums)):
        moving_sum = moving_sum + nums[i] - nums[i - k]
        res = max(res, moving_sum)
    return res/k

进阶:求max

四、Longest Continuous Increasing Sunsequence

Given an unsorted array of integers, find the length of longest continuous increasing subsequence (subarray).

def findLongest(nums):
    result, count = 0, 0
    for i in range(len(nums)):
        if i == 0 or nums[i - 1] < nums[i]:
            count += 1
            result = max(result, count)
        else:
            count = 1
    return result

五、Minimum Size Subarray Sum

Given an array of n positive integers and a positive integer s, find the minimal length of a contiguous subarray of which the sum ≥ s. If there isn't one, return 0 instead

Given the array [2,3,1,2,4,3] and s = 7

the subarray [4,3] has the minimal length under the problem constraint 

#什么时候是一个invalid的窗口，什么时候是一个valid的窗口
#invalid-->valid j+  valid--> i-打破 O（n）
import sys
def minsubarray(nums, target):
    i = j = sum = 0
    count = sys.maxsize
    while j < len(nums):
        sum += nums[j]
        j += 1
        while sum > target:
            count = min(j - i, count)
            sum -= nums[i]
            i += 1
    return 0 if count == sys.maxsize else count

什么时候移动i，什么时候移动j-->基本上有两个while循环，一个是while j<len， 第二个是当找到一个好窗口的时候，需要去打破它，while condition 打破窗口

六、Implement strStr() ************

Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

def solution(s1, s2): #O(mn)
    if len(s1) < len(s2):
        return None
    i = 0
    while i < len(s1) - len(s2) + 1:
        j = 0
        k = i
        while j < len(s2):
            if s1[k] == s2[j]:
                k += 1
                j += 1
            else:
                break
        if j == len(s2):
            break
        else:
            i += 1
    if i == len(s1) - len(s2) + 1:
        return None
    else:
        return s1[i:]

# 
class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        if needle is '':
            return 0
        if len(needle) > len(haystack):
            return -1
        i = 0
        while i < len(haystack) - len(needle) + 1:
            j = 0
            while j < len(needle) and needle[j] == haystack[i + j]:
                if j == len(needle) - 1:
                    return i
                j += 1
            i += 1
        return -1

七、Subarray Product Less Than K

Your are given an array of positive integers nums

Count and print the number of (contiguous) subarrays where the product of all the elements in the subarray is less than k

def solution(nums, target):
    i = 0
    count = 0
    while i < len(nums):
        mul = nums[i]
        j = i
        while j < len(nums) and mul < target:
            count += 1
            j += 1
            if j < len(nums):
                mul = mul * nums[j]
        i += 1
    return count

def numSubarrayProductLessThanK(nums, k):
    product = 1
    i = 0
    ans = 0
    for j, num in enumerate(nums):
        product *= num
        while product >= k:
            product /= nums[i]
            i += 1
        ans += (j - i + 1)
    return ans