Tips

和402一脉相承，单调栈+贪心。原理来源于高位的字符越小整体的字典序越小,所以对于存在重复的字符，只要该字符在栈尾，且新的元素比它更小，就自动pop

1. 和402一脉相承，单调栈+贪心。原理来源于高位的字符越小整体的字典序越小,所以对于存在重复的字符，只要该字符在栈尾，且新的元素比它更小，就自动pop

2. 这里有个两个计数存储，seen用来判断是否入栈，已经在栈内的元素不入栈，hash的计数用来判断是否出栈，如果没有剩余元素则不能出栈

Tips

有效括号的升级版。计算最长的连续有效括号，计算括号是否有效通过左括号入栈，右括号弹出的操作可以实现，但是最长连续这里又一点tricky。其实是通过右括号也入栈来对有效的括号进行隔断。如果只有右括号，则右括号自动隔断前面的所有有效括号，这里stack=[-1]的初始位置是精髓

有效括号的升级版。计算最长的连续有效括号，计算括号是否有效通过左括号入栈，右括号弹出的操作可以实现，但是最长连续这里又一点tricky。

1. 左括号多：左括号本身不会被消掉，所以左index+1

2. 右括号多：没有左括号与之匹配，所以右括号入栈形成隔断

- 234 回文链表：中间节点+翻转链表+遍历

- 设计类

- 146 LRU：双向链表，插入head(先建立node左右link，再插入），超过长度移除tail.prev, 移除是把元素左右node链接

- 460 LFU：

- 707 设计链表

- 技巧题

- 160 相交链表：

- 382 链表随机节点：蓄水池算法，第K个节点有1/K的概率overwrite之前sample的元素

- 160 相交链表：不用技巧，常规解法是把两个链表拼接到相同长度，然后开始遍历寻找相同节点

- 382 链表随机节点：蓄水池算法，第K个节点有1/K的概率被采样

ifnot head:

middle=self.find_middle(head)

l2= middle.next

l1= head

middle.next=None

l2=self.reverse(l2)

result=self.merge_linklist(l1, l2)

deffind_middle(head):

slow=head

fast= head

while fast.nextand fast.next.next:

fast= fast.next.next

slow= slow.next

return slow

defreverse(head):

cur= head

newnode=None

while cur:

tmp= cur.next

cur.next= newnode

newnode= cur

cur= tmp

return newnode

defmerge_linklist(head1,head2):

while head1and head2:

tmp1= head1.next

tmp2= head2.next

head1.next= head2

head1= tmp1

head2= tmp2

defreverse(head):

newnode=None

cur= head

while cur:

nextnode= cur.next

cur.next=newnode

newnode= cur

cur= nextnode

return newnode

defgetmid(head):

slow, fast= head, head

while fast.nextand fast.next.next:

slow= slow.next

fast= fast.next.next

return slow

defmerge(l1,l2):

while l1and l2:

l1_tmp= l1.next

l2_tmp= l2.next

l1.next= l2

l1= l1_tmp

l2.next= l1

l2= l2_tmp

ptr1= head

left_mid= getmid(head)

mid= left_mid.next

left_mid.next=None# 注意这一步

ptr2= reverse(mid)

merge(ptr1, ptr2)

Tips

1. 这道题融合了三道题，快慢指针找中点，反转链表，合并两个链表

1. 这道题融合了三道题，快慢指针找中点，反转链表，合并两个链表

2. 比148多了融合这一步，融合是在原地进行的只改变link不改变value

3. 需要注意的是这里find_mid找的是中点的左边界，因为需要设置mid.next=None, 把前半部分隔出来

Tips:

1. 注意链表的赋值一般都是对next，这样可以有效避免创建空节点。如果每次val都是赋值给当前节点，则需要额外判断l1和l2是否为空决定是否创建链表的next节点

2. 注意审题，是顺序向后加，remainder也是加在后面

蓄水池抽样

N个候选，第K个候选被采用的概率是1/K，

- K=1， p=1

- K=2, p=1/2，覆盖K=1的概率是1/2

- K=3, p=1/3,覆盖之前的概率是2/3，所以K=2的元素被选择的概率变成1/2 * 2/3 = 1/3

- K=3, p=1/3,第3个节点本身被采样的概率论是1/3，保留之前随机数的概率是2/3，所以K=2的元素被选择的概率变成1/2 * 2/3 = 1/3

- 234 回文链表：中间节点+翻转链表+遍历

- 设计类

- 146 LRU：双向链表，插入head(先建立node左右link，再插入），超过长度移除tail.prev, 移除是把元素左右node链接

- 460 LFU：

- 707 设计链表

- 技巧题

- 160 相交链表：可以用常规接发， 找到长度，拼接成相同长度，然后遍历判断是否有相交节点

- 382 链表随机节点：蓄水池算法，第K个节点有1/K的概率overwrite之前sample的元素

- 160 相交链表：不用技巧，常规解法是把两个链表拼接到相同长度，然后开始遍历寻找相同节点

- 382 链表随机节点：蓄水池算法，第K个节点有1/K的概率被采样

也就是当slow和fast在C点相遇后，只要有一个ptr从head开始，和slow一起向前跑，当slow再次走到C，并绕着环跑了n-1圈后，两者会在B相遇

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln - 1 → Ln

classListNode:

def__init__(self,val=0,next=None):

self.val= val

self.next=next

def__str__(self):

res= []

cur=self

while cur:

res.append(str(cur.val))

cur= cur.next

return'->'.join(res)

classSolution:

defreorderList(self,head: ListNode) ->None:

ifnot head:

middle=self.find_middle(head)

l2= middle.next

l1= head

middle.next=None

l2=self.reverse(l2)

result=self.merge_linklist(l1, l2)

deffind_middle(head):

slow=head

fast= head

while fast.nextand fast.next.next:

fast= fast.next.next

slow= slow.next

return slow

defreverse(head):

cur= head

newnode=None

while cur:

tmp= cur.next

cur.next= newnode

newnode= cur

cur= tmp

return newnode

defreverse(head):

newnode=None

cur= head

while cur:

nextnode= cur.next

cur.next=newnode

newnode= cur

cur= nextnode

return newnode

defgetmid(head):

slow, fast= head, head

while fast.nextand fast.next.next:

slow= slow.next

fast= fast.next.next

return slow

defmerge(l1,l2):

while l1and l2:

l1_tmp= l1.next

l2_tmp= l2.next

defmerge_linklist(head1,head2):

while head1and head2:

tmp1= head1.next

tmp2= head2.next

head1.next= head2

l1.next= l2

l1= l1_tmp

l2.next= l1

l2= l2_tmp

ptr1= head

left_mid= getmid(head)

mid= left_mid.next

left_mid.next=None# 注意这一步

Tips

1. 这道题融合了三道题，快慢指针找中点，反转链表，合并两个链表

2. 比148多了融合这一步，融合是在原地进行的只改变link不改变value

3. 需要注意的是这里find_mid找的是中点的左边界，因为需要设置mid.next=None, 把前半部分隔出来

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。

- 插入搜索：如果比当前位置大直接插入，如果小就会到链表的起点进行重新搜索

- 注意比较时只能比较next节点，如果比较当前节点无法插入

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

蓄水池抽样

N个候选，第K个候选被采用的概率是1/K，

- K=1， p=1

- K=2, p=1/2，覆盖K=1的概率是1/2

- K=3, p=1/3,覆盖之前的概率是2/3，所以K=2的元素被选择的概率变成1/2 * 2/3 = 1/3

- K=3, p=1/3,第3个节点本身被采样的概率论是1/3，保留之前随机数的概率是2/3，所以K=2的元素被选择的概率变成1/2 * 2/3 = 1/3

请你为 最不经常使用（LFU）缓存算法设计并实现数据结构。

实现 LFUCache 类：

注意「项的使用次数」就是自插入该项以来对其调用 get 和 put 函数的次数之和。使用次数会在对应项被移除后置为 0 。

为了确定最不常使用的键，可以为缓存中的每个键维护一个 使用计数器 。使用计数最小的键是最久未使用的键。

当一个键首次插入到缓存中时，它的使用计数器被设置为 1 (由于 put 操作)。对缓存中的键执行 get 或 put 操作，使用计数器的值将会递增。

示例：

输入：

["LFUCache", "put", "put", "get", "put", "get", "get", "put", "get", "get", "get"]

[[2],[1, 1],[2, 2],[1],[3, 3],[2],[3],[4, 4],[1],[3],[4]]

输出：

[null, null, null, 1, null, -1, 3, null, -1, 3, 4]

解释：

// cnt(x) = 键 x 的使用计数

// cache=[] 将显示最后一次使用的顺序（最左边的元素是最近的）

LFUCache lFUCache = new LFUCache(2);

lFUCache.put(1, 1); // cache=[1,_], cnt(1)=1

lFUCache.put(2, 2); // cache=[2,1], cnt(2)=1, cnt(1)=1

lFUCache.get(1); // 返回 1

// cache=[1,2], cnt(2)=1, cnt(1)=2

lFUCache.put(3, 3); // 去除键 2 ，因为 cnt(2)=1 ，使用计数最小

// cache=[3,1], cnt(3)=1, cnt(1)=2

lFUCache.get(2); // 返回 -1（未找到）

lFUCache.get(3); // 返回 3

// cache=[3,1], cnt(3)=2, cnt(1)=2

lFUCache.put(4, 4); // 去除键 1 ，1 和 3 的 cnt 相同，但 1 最久未使用

// cache=[4,3], cnt(4)=1, cnt(3)=2

lFUCache.get(1); // 返回 -1（未找到）

lFUCache.get(3); // 返回 3

// cache=[3,4], cnt(4)=1, cnt(3)=3

lFUCache.get(4); // 返回 4

// cache=[3,4], cnt(4)=2, cnt(3)=3

提示：

进阶：你可以为这两种操作设计时间复杂度为 O(1) 的实现吗？