滑动窗口——X庸置疑

要点：连续、无重复、 子串 步骤：窗口右边随循环扩张，待到右边元素存在窗口内时调整左窗口直到右边子元素不存在于窗口中，每次迭代更新子串长度

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        char_set = set()#保留窗口内的不重复子串
        left = 0
        max_len = 0
        for right in range(len(s)):
            while s[right] in char_set:
                char_set.remove(s[left])
                left += 1
            char_set.add(s[right])
            max_len = max(max_len,right-left+1)
        return max_len

逆转链表——头插法解决 or 双指针逆反

头插，一定是新插入的在最前面

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseList(self, head):
        """
        :type head: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        fake_head = ListNode(-1)
        fake_head.next = None
        #前插法
        p = head
        while p:
            temp = fake_head.next
            temp1 = p.next
            fake_head.next = p
            p.next = temp
            p = temp1
        return fake_head.next

p1、p2的状态， p1最终指向None， p2最终指向 新头节点； 该解法关注p1、p2的init状态、状态走向以及最终指代即可。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseList(self, head):
        """
        :type head: Optional[ListNode]
        :rtype: Optional[ListNode]
        """
        p1 = head
        p2 = None
        while p1:
            temp = p1.next
            p1.next = p2
            p2 = p1
            p1 = temp
        return p2

第k大的数

用小根堆，考数据结构，没想到 python默认小根堆，这里操作很诡异，还要自备容器。

class Solution(object):
    def findKthLargest(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        heap = []
        for num in nums:
            heapq.heappush(heap,num)
            if len(heap) > k:
                heapq.heappop(heap)
        return heap[0]

k组逆转——断舍离有难度

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseKGroup(self, head, k):
        """
        :type head: Optional[ListNode]
        :type k: int
        :rtype: Optional[ListNode]
        """
    #嵌套式逆转
        if not head or k == 1:
            return head
        dummy = ListNode(-1)
        dummy.next = head
        group_prev = dummy

        while True:
            kth = group_prev
            for _ in range(k):
                kth = kth.next
                if not kth:
                    return dummy.next
            group_next = kth.next
            kth.next = None
            group_head = group_prev.next

            head_new = self.reverseList(group_head)

            #join
            group_prev.next = head_new
            group_head.next = group_next

            group_prev = group_head

        return dummy.next

    def reverseList(self,head):
        prev = None
        cur = head
        while cur:
            temp = cur.next
            cur.next = prev
            prev = cur
            cur = temp
        return prev