coding

（1）LC300：最长上升子序列【【LeetCode】最长上升子序列 python ★★★★★★_yingzoe的博客-CSDN博客_最长上升子序列python】

（2）LC673：最长递增子序列个数

（3）LC167改造：two_sum（有序数组，输出所有组合）：设计一个算法找到数组中两个元素相加等于指定数的所有组合_jia635的专栏-CSDN博客_找出数组里面任意两个数相加等于某个k值的组合

#两数之和 升序数组【多组答案，要求有序】
def solve(arr,target):
    i = 0
    j = len(arr) - 1
    res = []
    while i < j:
        if arr[i] + arr[j] == target:
            res.append([i+1,j+1])
            i += 1
            j -= 1
        elif arr[i] + arr[j] < target:
            i += 1
        else:
            j -= 1
    return res

（4）LC15：three_sum（有序数组）：力扣

def threeSum(arr):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        arr.sort()
        if not arr:
            return []
        if arr[0] > 0: #注意不能取等号  有[0,0,0]情况
            return []
        n = len(arr)
        res = []
        for i in range(n):
            if i > 0 and arr[i] == arr[i-1]:
                continue
    #         first = arr[i]
            second = i+1
            third = n-1
            while second < third:
                if arr[i] + arr[second] + arr[third] == 0:
                    res.append([arr[i],arr[second],arr[third]])
                    while second < third and arr[second] == arr[second+1]:
                        second += 1
                    while second < third and arr[third] == arr[third-1]:
                        third -= 1
                    second += 1
                    third -= 1
                elif arr[i] + arr[second] + arr[third] < 0:
                    second += 1
                else:
                    third -= 1
        return res

（5）青蛙上台阶

def solve(n):
    if n < 2:
        return 1
    f1 = 1
    f2 = 1
    for i in range(2,n+1):
        fn = f1 + f2
        f1 = f2
        f2 = fn
    return fn % 1000000007

（6）只出现一次的数字【力扣】

#20201210

（1）旋转数组找最小值

（2）旋转数组找指定值【力扣】

def solve(data,target):
    left = 0
    right = len(data) - 1
    while left <= right:
        mid = (left + right) // 2
        if data[mid] == target:
            return mid
        if data[0] <= data[mid]:#左边是有序数组
            if data[left] <= target < data[mid]:
                right -= 1
            else:
                left += 1
        else:
            if data[mid] < target <= data[len(data)-1]:
                left += 1
            else:
                right -= 1
    return -1

#20201219

（1）股票最佳时机（一次）【力扣】

（2）股票最佳时机（多次）【力扣】

#20201220

（1）LC200：岛屿数量【力扣】

#深度优先
def solve(arr):
    row = len(arr)
    if row == 0:
        return 0
    col = len(arr[0])
    res = 0 #记录岛屿数量
    for i in range(row):
        for j in range(col):
            if arr[i][j] == '1':
                res += 1
                dfs(arr,i,j)
    return res
def dfs(arr,x,y):
    arr[x][y] = '0'
    row, col = len(arr), len(arr[0])
    for i, j in [(x-1,y),(x,y-1),(x,y+1),(x+1,y)]:
        if 0 <= i and i < row and 0 <= j and j < col and arr[i][j] == '1':
            dfs(arr,i,j)

#广度优先
from collections import deque
def solve(arr):
    row = len(arr)
    if row == 0:
        return 0
    col = len(arr[0])
    res = 0
    for i in range(row):
        for j in range(col):
            if arr[i][j] == '1':
                res += 1
                deque_list = deque([(i,j)])
                while deque_list:
                    col_x, col_y = deque_list.popleft()
                    for x, y in [(col_x-1,col_y),(col_x,col_y-1),(col_x+1,col_y),(col_x,col_y+1)]:
                        if x >= 0 and x < row and y >= 0 and y< col and arr[x][y] == '1':
                            deque_list.append((x,y))
                            arr[x][y] = 0
    return res

（2）两数之和

def solve(data,target):
    res = {}
    for i in range(len(data)):
        if target - data[i] in res:
            return [i,res[target-data[i]]]
        else:
            res[data[i]] = i
    return -1

（3）三数之和

def solve(data):
    data.sort()
    n = len(data)
    res = []
    if data[0] > 0:
        return res
    for i in range(n):
        if i > 0 and data[i] == data[i-1]:
            continue#第一个指针的初始位置，跳过重复值
        left = i + 1
        right = n-1
        while left < right:
            if data[i] + data[left] + data[right] == 0:
                res.append([data[i],data[left],data[right]])
                while left < right and data[left] == data[left+1]:
                    left += 1
                while left < right and data[right] == data[right-1]:
                    right -= 1
                left += 1
                right -= 1
            elif data[i] + data[left] + data[right] > 0:
                right -= 1
            else:
                left += 1
    return res
                    
        
        

#20200106

（1）二维有序数组找target

（2）K路归并

#20200107

（1）第K大的数

#20200108

（1）最长公共子串

（2）最小的K个数

（3）最长回文子串【LC5】

（4）全排列【LC46】

（5）二叉树最近公共祖先【LC236】

（6）二叉树层序遍历

（7）二叉树序列化、反序列化

（8）二叉树上和为target的最长路径

（9）翻转链表中偶数位置的值

（10）从K个整数中组合出被3整除的最大数【LC1363】

#20210109 MicroSoft

（0）二叉树定义

# Definition for a binary tree node.
class TreeNode:
     def __init__(self, x):
         self.val = x
         self.left = None
         self.right = None

（0-1）ListNode定义

class ListNode:
    def __init__(self,val=0,next=None):
        self.val = val
        self.next = next

（1）LC208：字典树实现

（2）LC705、LC706：哈希表实现

（3）LC8：字符串转换整数（atoi）

#atoi【自动状态机】
'''
              ['', +/-, number, other]
start:        [start,signed,in_number,end]
signed:       [end,end,in_number,end]
in_number:    [end,end,in_number,end]
end:          [end,end,end,end]
'''
MAX = 2 ** 31 - 1
MIN = -2 ** 31
# print(MAX)
class Automation:
    def __init__(self):
        self.state = 'start'
        self.sign = 1
        self.ans = 0
        self.table = {
            'start':['start','signed','in_number','end'],
            'signed':['end','end','in_number','end'],
            'in_number':['end','end','in_number','end'],
            'end':['end','end','end','end']
        }
    def get_col(self,c):
        if c.isspace():
            return 0
        if c == '+' or c == '-':
            return 1
        if c.isdigit():
            return 2
        return 3
    def get(self,c):
        self.state = self.table[self.state][self.get_col(c)]
        if self.state == 'in_number':
            self.ans = self.ans * 10 + int(c)
#             print(min(self.ans,MAX))
            self.ans = min(self.ans,MAX) if self.sign == 1 else min(self.ans,-MIN)
        elif self.state == 'signed':
            self.sign = 1 if c == '+' else -1
class Solution:
    def myAtoi(self,string):
        automation = Automation()
        for s in string:
            automation.get(s)
#             print(automation.ans)
        return automation.sign * automation.ans

（4）LC297：二叉树序列化、反序列化

#深度优先
class Codec:
    def serialize(self,root):
        res = []
        def dfs(node):
            if node:
                res.append(str(node.val))#注意字符转化
                dfs(node.left)
                dfs(node.right)
            else:
                res.append('null')
        dfs(root)
        return '[' + ','.join(res) +']'
    def deserialize(self,data):
        vals = data[1:-1].split(',')
        def dfs():
            first = vals.pop(0)
            if first == 'null':
                return None
            else:
                node = TreeNode(int(first))
                node.left = dfs()
                node.right = dfs()
            return node
        return dfs()

#广度优先
from collections import deque
class Codec:
    def serialize(self,root):
        if not root:
            return '[]'
        quene = deque([root])
        res = []
        while quene:
            node = quene.popleft()
            if not node:
                res.append('null')
            else:
                res.append(str(node.val))
                quene.append(node.left)
                quene.append(node.right)
        return '[' + ','.join(res) + ']'
    def deserialize(self,data):
        if data == '[]':
            return None
        vals = data[1:-1].split(',')
        root = TreeNode(int(vals[0]))
        quene = deque([root])
        i = 1
        while quene:
            node = quene.popleft()
            if vals[i] != 'null':
                node.left = TreeNode(int(vals[i]))
                quene.append(node.left)
            i += 1
            if vals[i] != 'null':
                node.right = TreeNode(int(vals[i]))
                quene.append(node.right)
            i += 1
        return root
        

（5）LC295：数据流中位数

（6）LC33：旋转数组找指定值

（7）LC53：最大子数组和

（8）前序、中序、后序二叉树，怎么恢复

（9）LC215：第K大的元素

#第K大的数 
#快排
def quickSort(arr,start,end):
    low = start
    high = end 
    base = arr[start]
    while low < high:
        while low < high and arr[high] >= base:
            high -= 1
        arr[low] = arr[high]
        while low < high and arr[low] < base:
            low += 1
        arr[high] = arr[low]
    arr[low] = base
#     quickSort(arr,start,low-1)
    return low
def findKthLargest(arr,k):
    k = len(arr) - k
    start = 0
    end = len(arr) - 1
    while True:
        loc = quickSort(arr,start,end)
        if loc == k:
            return arr[loc]
        elif loc < k:
            start = loc + 1
        else:
            end = loc - 1

（9-0）剑指offer 40：最小的K个数

#最小的K个数
#堆 自己实现大顶堆
# 若是找最大的K个数 使用小顶堆 每次把最小的数排出去
# 复杂度 nlog(k)
def getLeastNumbers(arr,k):
    if k == 0:
        return []
    data = arr[:k]
    build_heap(data,len(data))  ##实现
    for each in arr[k:]:
        if data[0] > each:
            data[0] = each
            heapify(data,len(data),0)
    return data
def build_heap(arr,n):
    i = n // 2
    while i >= 0:
        heapify(arr,n,i)
        i -= 1
def heapify(arr,n,i):
    left = 2 * i
    right = 2 * i + 1
    largest = i
    if left < n and arr[left] > arr[i]:
        largest = left
    if right < n and arr[right] > arr[largest]:
        largest = right
    if largest != i:
        arr[i],arr[largest] = arr[largest],arr[i]
        heapify(arr,n,largest)

# 快排实现 复杂度期望O(n)
def quickSort_kernel(lst, start, end):
#     if start > end:
#         return
    base = lst[start]
    low = start
    high = end
    while low < high:
        while low < high and lst[high] >= base: # 若是最大的改这里
            high -= 1
        lst[low] = lst[high]
        while low < high and lst[low] <= base: # 若是最大的改这里
            low += 1
        lst[high] = lst[low]
    lst[low] = base
    return low
def solve(lst, k):
    start = 0
    end = len(lst) - 1
    loc = quickSort_kernel(lst, start, end)
    while loc != k:
        if loc > k - 1:
            end = loc - 1
        else:
            start = loc + 1
        loc = quickSort_kernel(lst, start, end)
    return lst[:k]

（10）LC131：分割回文串

（11）汉字数字转数字【Python将汉字数字转换成阿拉伯数字的方法_yusisc的博客-CSDN博客_python中文数字转阿拉伯数字】

（12）LC102：二叉树层序遍历

#深度优先
def levelOrder(root):
    if not root:
        return []
    res = []
    def dfs(index,r):
        if len(res) < index:
            res.append([])
        res[index-1].append(r.val)
        if r.left:
            dfs(index+1,r.left)
        if r.right:
            dfs(index+1,r.right)
    dfs(1,root)
    return res

#广度优先
def levelOrder(root):
    if not root:
        return []
    quene = [root]
    res = []
    while quene:
        tmp = []
        for _ in range(len(quene)):
            node = quene.pop(0)
            tmp.append(node.val)
            if node.left:
                quene.append(node.left)
            if node.right:
                quene.append(node.right)
#         else:
#             tmp.append('null')
        res.append(tmp)
    return res

（13）LC103：二叉树之字形层序遍历

（14）LC560：和为K的子数组数量

（15）LC34：排序数组中元素第一个和最后一个位置

（16）LC155：最小栈

（17）LC232：栈实现队列

（18）LC225：队列实现栈

（19）LC450：二叉搜索树删除

（20）LC137：只出现一次数字（其余数字出现三次）

（21）LC4：两个有序数组中位数

（22）长度为N的环 走K步 从原点到原点【【面试题】一个环，有n个点, 问从0点出发，经过k步回到原点有多少种方法_苏学算法的博客-CSDN博客】

（23）LC852：山脉数组峰顶索引

def solve(arr):
    low = 0
    high = len(arr) - 1
    while low < high:
        mid = (low + high) // 2
        if arr[mid] < arr[mid+1]:
            low = mid + 1
        else:
            high = mid
    return low

（24-0）LC21：2路归并

#二路归并
#递归
def mergeTwoLists(arr1,arr2):
    if arr1 is None:
        return arr2
    elif arr2 is None:
        return arr1
    elif arr1.val < arr2.val:
        arr1.next = mergeTwoLists(arr1.next,arr2)
        return arr1
    else:
        arr2.next = mergeTwoLists(arr1,arr2.next)
        return arr2

#迭代
def mergeTwoLists(arr1,arr2):
    prehead = ListNode(-1)
    prev = prehead
    while arr1 and arr2:
        if arr1.val < arr2.val:
            prev.next = arr1
            arr1 = arr1.next
        else:
            prev.next = arr2
            arr2 = arr2.next
        prev = prev.next
    prev.next = arr2 if arr1 is None else arr1
    return prehead.next

（24）LC23：k路归并

#K路归并
#heap
def mergeKLists(arr):
    import heapq
    if not arr:
        return None
    dummy = ListNode(-1)
    p = dummy
    head = []
    for i in range(len(arr)):#push每个链表第一个数
        if arr[i]:
            heapq.heappush(head,(arr[i].val,i))
            arr[i] = arr[i].next
    while head:
        val, idx = heapq.heappop(head)
        p.next = ListNode(val)
        p = p.next
        if arr[idx]:
            heapq.heappush(head,(arr[idx].val,idx))
            arr[idx] = arr[idx].next
    return dummy.next
        

#k路归并
#分治
def mergeKLists(arr):
    if not arr:
        return None
    def split(start,end):
        if start == end:
            return arr[start]
        mid = start + (end - start) / 2
        left = split(start,mid)
        right = split(mid+1,end)
        return merge(left,right)
    def merge(a,b):
        prev = ListNode(0)
        prehead = prev
        while a and b:
            if a.val < b.val:
                prehead.next = a
                a = a.next
            else:
                prehead.next = b
                b = b.next
            prehead = prehead.next
        prehead.next = b if a is None else a
        return prev.next
    return split(0,len(arr)-1)
    

（25）LC516：回文子序列

（26）LC240：搜索二维矩阵

#二维数组查找
def searchMatrix(arr,target):
    if not arr:
        return False
    for i in range(min(len(arr),len(arr[0]))):
        vertical = find(arr,target,i,True)
        horizon = find(arr,target,i,False)
        if vertical or horizon:
            return True
    return False
def find(arr,target,start,flag):
    low = start
    high = len(arr[0])-1 if flag else len(arr)-1
    while low <= high:
        mid = (low + high) // 2
        if flag:
            if arr[start][mid] < target:
                low = mid + 1
            elif arr[start][mid] > target:
                high = mid - 1
            else:
                return True
        else:
            if arr[mid][start] < target:
                low = mid + 1
            elif arr[mid][start] > target:
                high = mid - 1
            else:
                return True
    return False

（27）LC141：环形链表

#环形链表
#记录元素
def hasCycle(head):
    res = set()
    while head:
        if head in res:
            return True
        res.add(head)
        head = head.next
    return False

#环形链表
#快慢指针
def hasCycle(head):
    if not head or not head.next:
        return False
    slow = head
    fast = head.next
    while slow != fast:
        if not fast or not fast.next:
            return False
        slow = slow.next
        fast = fast.next.next
    return True

#20200110

（1）LC228：汇总区间

#蓄水池抽样
def summaryRanges(arr):
    n = 0
    res = []
    while n < len(arr):
        if n + 1 < len(arr) and arr[n] + 1 == arr[n+1]:
            m = n
            while n + 1 < len(arr) and arr[n] + 1 == arr[n+1]:
                n += 1
            res.append('{}->{}'.format(arr[m],arr[n]))
        else:
            res.append(str(arr[n]))
        n += 1
    return res

#20210111

（1）LC46：所有排列

#全排列
def solve(arr):
    res = []
    n = len(arr)
    def back(first):
        if first == n:
            res.append(arr[:])
        for i in range(first,n):
            arr[first],arr[i] = arr[i],arr[first]
            back(first + 1)
            arr[first],arr[i] = arr[i],arr[first]
    back(0)
    return res

（2）LC674：最长连续递增序列

def findLengthOfLCIS(arr):
    if len(arr) < 2:
        return len(arr)
    j = 1
    res = 0
    for i in range(len(arr)-1):
        if arr[i+1] > arr[i]:
            j += 1
        else:
            j = 1
        res = max(res,j)
    return res

#20210111 SOUHU

（1）LC74：搜索二维数组

def solve(arr,target):
    m = len(arr)
    if m == 0:
        return False
    n = len(arr[0])
    left,right = 0, m * n -1
    while left <= right:
        mid = (left + right) // 2
        element = arr[mid // n][mid % n]
        if target == element:
            return True
        elif target < element:
            right = mid - 1
        else:
            left = mid + 1
    return False
    

（2）剑指offer 07：重建二叉树

def solve(preorder,inorder):
    dic = {inorder[i]:i for i in range(len(inorder))}
    def back(root,left,right):
        if left > right:
            return
        node = TreeNode(preorder[root])
        i = dic[preorder[root]]
        node.left = back(root+1,left,i-1)
        node.right = back(i-left+root+1,i+1,right)
        return node
    return back(0,0,len(inorder)-1)

#20210112

（1）LC325：和为target的最长子数组长度

#和为k的最长子数组长度
def solve(arr,target):
    if not arr:
        return 0
    dic = {}
#     dic[0] = -1
    res = 0
    sums = 0
    for i in range(len(arr)):
        sums += arr[i]
        if sums == target:
            res = i + 1
        elif sums - target in dic:
            res = max(i - dic[sums - target], res)
        else:
            dic[sums] = i
    return res

（2）LC4：两个正序数组的中位数

#两个数组的中位数
def solve(arr1,arr2):
    def findK(k):
        index1 = 0
        index2 = 0
        while True:
            if m == index1:
                return arr2[index2+k-1]
            if n == index2:
                return arr1[index1+k-1]
            if k == 1:
                return min(arr1[index1],arr2[index2])
            newIndex1 = min(index1+k // 2-1,m-1)
            newIndex2 = min(index2+k // 2-1,n-1)
            base1 = arr1[newIndex1]
            base2 = arr2[newIndex2]
            if base1 <= base2:
                k -= newIndex1 - index1 + 1
                index1 = newIndex1 + 1
            else:
                k -= newIndex2 - index2 + 1
                index2 = newIndex2 + 1
    m = len(arr1)
    n = len(arr2)
    if (m + n) % 2 == 1:
        return findK((m+n+1)//2)
    else:
        return 0.5 * (findK((m+n)//2) + findK((m+n)//2+1))

（3）多个有序数组合并【合并k个有序数组 - tanshoudong - 博客园】

（4）合并两个有序数组

def solve(nums1,m,nums2,n):
    p1 = m - 1
    p2 = n - 1
    p = m + n - 1
    while p1 >= 0 and p2 >= 0:
        if nums1[p1] < nums2[p2]:
            nums1[p] = nums2[p2]
            p2 -= 1
        else:
            nums1[p] = nums1[p1]
            p1 -= 1
        p -= 1
    nums1[:p2+1] = nums2[:p2+1]
#     return nums1

（5）单链表翻转

#反转链表
def solve(head):
    pre = None
    cur = head
    while cur:
        tmp = cur.next
        cur.next = pre
        pre = cur
        cur = tmp
    return pre

#20210114

（1）蓄水池抽样【[总结]随机抽样与蓄水池抽样问题 - Jamest - 博客园】

#20210121

（1）LC337：打家劫舍（树形动态规划）

#打家劫舍
def solve(root):
    tmp = find(root)
    return max(tmp[0], tmp[1])
def find(root):
    if not root:
        return [0,0]
    left = find(root.left)
    right = find(root.right)
    tou = root.val + left[1] + right[1]
    butou = max(left[0], left[1]) + max(right[0], right[1])
    return [tou, butou]

（2）LC198：打家劫舍（动态规划）

def solve(arr):
    if not arr:
        return 0
    n = len(arr)
    if n == 1:
        return arr[0]
    dp = [0] * n
    dp[0] = arr[0]
    dp[1] = max(arr[0], arr[1])
    for i in range(2,n):
        dp[i] = max(dp[i-1], dp[i-2]+arr[i])
    return dp[n-1]

#20210124

（1）数组中和为target的全部组合 

#20210131

（1）剪绳子1：剑指14-1