CodeTop.1

1. 无重复字符的最长子串

1.1. 题目描述

给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。

示例 1:

输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: s = “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

提示：

0 <= s.length <= 5 * 104
s 由英文字母、数字、符号和空格组成

1.2. 题目解析

双指针，右指针指向的字母在子串中则左指针+1，否则右指针+1

1.3. 代码

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if len(s) < 2:
            return len(s)
            
        max_len = 0
        l, r = 0, 1

        while r < len(s):
            if s[r] not in s[l:r]:
                max_len = max(max_len, r - l + 1)
                r += 1
            else:
                l += 1
        return max_len

2. LRU缓存

最近看到一些帖子，建议这些常见的题目能默写出来。
其他常见题目参见 CodeTop

2.1. 题目描述

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache 类：
LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。
函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入
[“LRUCache”, “put”, “put”, “get”, “put”, “get”, “put”, “get”, “get”, “get”]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4

提示：

1 <= capacity <= 3000
0 <= key <= 10000
0 <= value <= 105
最多调用 2 * 105 次 get 和 put

2.2. 题目解析

哈希表 + 双向链表。
链表的处理稍微麻烦一点，形象一点的理解：

1. 链表
   两个人互相单手揪着对方领子称为链表。左手抓着定义为上家，右手定义为下家

2. 删除节点
   ABC三个人互相揪着对方的领子，B被夹在中间。C发现A才是最大敌人，左手一松，抓住了A的脖子，与此同时A不甘示弱抓住了C的脖子

3. 插入节点
   AC两人互相揪着对方领子，来了个B，说你们都是辣鸡，并一手一个抓住了AC的领子。AC很上头，揪着B的领子让他再说一遍

2.3. 代码

class Node:
	def __init__(self, k=None, v=None):
		self.k = k
		self.v = v
		self.prev = None
		self.next = None

class LRUCache:
	def __init__(self, capacity):
		self.capacity = capacity
		self.cache = dict()
		self.size = 0
		
		self.head = Node()
		self.tail = Node()
		self.head.next, self.tail.prev = self.tail, self.head

	def get(self, k):
		if k in self.cache:
			self.move_to_tail(k)
		node = self.cache.get(k)
		return node.v if node else -1

	def put(self, k, v):
		if k in self.cache:
			self.cache[k].v = v
			self.move_to_tail(k)
		else:
			if self.size == self.capacity:
				# 删除哈希表里的数据
				node = self.cache.pop(self.head.next.k)
				# 删除链表节点
				left, right = node.prev, node.next
				left.next, right.prev = right, left
				# 修改规模
				self.size -= 1

			node = Node(k, v)
			# 哈希表记录新数据
			self.cache[k] = node
			# 链表插入节点
			left, right = self.tail.prev, self.tail
			node.prev, node.next = left, right
			left.next, right.prev = node, node
			# 修改规模
			self.size += 1

	def move_to_tail(self, k):
		node = self.cache[k]
		# 删除链表节点
		left, right = node.prev, node.next
		left.next, right.prev = right, left

		# 链表插入节点
		left, right = self.tail.prev, self.tail
		node.prev, node.next = left, right
		left.next, right.prev = node, node