基础知识补充
单向链表结构：item存储数据 next指向下一结点地址 head保存首地址
class Node(object): # 创建结点 def __init__(self, item): self.item = item # item存放数据元素 self.next = None # next是下一个结点的标识 class SingleLinkList(object): # 创建单链表 def __init__(self): self._head = None # 首地址 if __name__ == '__main__': link_list = SingleLinkList() # 创建链表 node1 = Node(1) # 创建结点 node2 = Node(2) link_list._head = node1 # 将结点添加到链表 node1.next = node2 # 将第一个结点的next指针指向下一结点 print(link_list._head.item) # 访问第一个结点数据 print(link_list._head.next.item) # 访问第二个结点数据双向链表结构：item存储数据 next指向下一结点地址 prev指向上一结点地址 head保存首地址
class Node(object): # 创建结点 def __init__(self, item): self.item = item # item存放数据元素 self.next = None # next是下一个结点的标识 self.prev = None # prev是上一个结点的标识 class SingleLinkList(object): # 创建单链表 def __init__(self): self._head = None # 首地址
基础操作补充
1.在链表头部添加元素：
def add(self, item): node = Node(item) # 定义新结点 node.next = self._head # 新结点指针指向原头部结点 self._head.prev = node # 原头部prev指向新结点——（双向链表） self._head = node # 头部结点指针修改为新结点2.在链表尾部添加元素：
def append(self, item): node = Node(item) cur = self._head while cur.next is not None: # 找到尾部 cur = cur.next node.prev = cur # (双向链表) cur.next = node更多操作见：python实现链表_python 实现一条链表,并打印输出链表内的元素内容(元素类型设置为整型即可)-CSDN博客
先调整新结点的指针，再将原指针指向新结点；
题目
160 相交链表
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
方法一：用集合存放某一链表的全部结点，遍历另一链表，结点相同时即找到相交结点；
class Solution(object): def getIntersectionNode(self, headA, headB): """ :type head1, head1: ListNode :rtype: ListNode """ A = set() cur1, cur2 = headA, headB while cur1: A.add(cur1) cur1 = cur1.next while cur2: if cur2 in A:return cur2 cur2 = cur2.next return None方法二：出现相交结点之后，所有结点相等，所以相交结点不可能出现在长链表的前(len1-len2)个结点中，只需要从短链表的头结点开始同步遍历判断是否相同即可；
class Solution: def getIntersectionNode(self, headA, headB): lenA, lenB = 0, 0 A, B = headA, headB # 计算长度 while A: A = A.next lenA += 1 while B: B = B.next lenB += 1 # 长链表先走，但不确定AB谁长，但实际上有至少一个循环不会执行 A, B = headA, headB for i in range(lenA-lenB): A = A.next for i in range(lenB-lenA): B = B.next # 两链表同步遍历 while A and B and A != B: A = A.next B = B.next return A #虽然比方法一多遍历了一轮，但节省了内存开销方法三：利用两链表的长度和相等；两指针分别从当前链表的头结点出发，移动到另一链表的尾结点，必定同时到达；而当出现相交结点时，从相交结点开始，两指针指向同一结点；
class Solution: def getIntersectionNode(self, headA, headB): A, B = headA, headB while not A == B: A = A.next if A else headB B = B.next if B else headA return A #两指针同时到达链表末尾时指向none，也会退出循环
206 反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
方法一：双指针 一个指向上一结点，一个指向当前结点，将当前结点的next指向上一结点即可；
class Solution(object): def reverseList(self, head): """ :type head: ListNode :rtype: ListNode """ pre, cur = None, head while cur: cur.next, cur, pre = pre, cur.next, cur #必须同步更新，不然更改指向后无法切换到下一结点（或者用一个新结点记录） return pre方法二：递归；终止条件：当前结点为空或下一结点为空，递归条件：head.next.next=head（环状）
补充理解：
class Solution(object): def reverseList(self, head): """ :type head: ListNode :rtype: ListNode """ if(head==None or head.next==None): # 递归终止条件是当前为空，或者下一个节点为空 return head cur = self.reverseList(head.next) head.next.next = head # 防止链表循环，需要将head.next设置为空 head.next = None return cur
234 回文链表
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表，如果是，返回 true ；否则，返回 false;
方法一：存为列表，然后判断list==list[::-1]，或者用一头一尾的双指针；
方法二：反转一半的链表，然后用双指针判断；
class Solution(object): def isPalindrome(self, head): """ :type head: ListNode :rtype: bool """ if head.next == None:return True # 链表长度仅为1 length, p = 0, head # 记录长度 while p: length += 1 p = p.next cnt = 0 pre, cur = None, head while cnt < length//2: # 反转一半 cur.next, cur, pre = pre, cur.next, cur cnt += 1 if length%2:cur=cur.next # 长度为奇数时跳过 # 此时pre为翻转的前一半的头结点，cnt为剩下一半的头结点 while pre and cur: if pre.val != cur.val:return False else: pre = pre.next cur = cur.next return True
141 环形链表
给你一个链表的头节点 head ，判断链表中是否有环。如果链表中存在环 ，则返回 true 。 否则，返回 false 。环：如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。
方法一：用集合记录下每一个结点，若该结点在集合中出现过，则存在环；
class Solution(object): def hasCycle(self, head): """ :type head: ListNode :rtype: bool """ H = set() p = head while p: if p in H:return True else: H.add(p) p = p.next return False方法二（官方思路）：快慢指针-龟兔赛跑，每次移动龟跑一步兔跑两步，如果没有循环，当兔到达终点结束；如果有循环，兔会被循环卡死，到龟进入循环后，由于相对位移仅为一步，龟和兔必定会相遇；
class Solution(object): def hasCycle(self, head): """ :type head: ListNode :rtype: bool """ slow, fast = head, head.next while slow != fast: if fast == None or fast.next == None:return False #fast跳了两步 else: slow = slow.next fast = fast.next.next return True
142 环形链表II
给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
方法一：用集合可以直接找出出现过的结点；
方法二：快慢指针
假设环结点到头结点的距离为x，环结点到双指针相遇的结点的距离为y，双指针相遇的结点到环结点的距离为z，则有：慢指针走x+y，快指针走x+n(y+z)+y；
因为两指针的移动次数相同，所以(x+y)*2=x+n(y+z)+y—— x=(n-1)(y+z)+z
当n=1时，x=z，即从相遇结点和头结点分别移动idx1和idx2，两者相遇的结点即为环结点；
当n>1时，因为(y+z)恰好为一个环的距离，相当于idx1和idx2还是会相遇，只是idx1多绕了n-1圈，同样两者相遇的结点是环结点；
class Solution(object): def detectCycle(self, head): """ :type head: ListNode :rtype: ListNode """ slow, fast = head, head while fast and fast.next: slow = slow.next fast = fast.next.next if slow == fast: idx1, idx2 = slow, head while idx1 != idx2: idx1 = idx1.next idx2 = idx2.next return idx1 return None需要注意的是，这里快慢指针需要同时出发，所以要先处理快慢指针再判断相等条件；
同时需要操作fast = fast.next.next，所以fast和fast.next都不能为none，141中的判断条件在这里需要改成and；
21 合并两个有序链表
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
方法一：创建一个头结点用于输出，并给其配一个指针；然后同时遍历升序链表，谁值小就将指针链接到谁，再将其移动到同链表的下一个结点；最后处理单个链表中的剩余结点；
class Solution(object): def mergeTwoLists(self, list1, list2): """ :type list1: Optional[ListNode] :type list2: Optional[ListNode] :rtype: Optional[ListNode] """ head = ListNode(0) #创建一个虚拟的头结点 p = head while list1 and list2: if list1.val < list2.val: p.next = list1 list1 = list1.next else: p.next = list2 list2 = list2.next p = p.next p.next = list1 if list1 else list2 #处理剩下的值 return head.next方法二：递归
终止条件：list1==None or list2 == None
循环事件：val1<val2时，list1需要指向list1.next和list2中的较小值；
class Solution(object): def mergeTwoLists(self, list1, list2): """ :type list1: Optional[ListNode] :type list2: Optional[ListNode] :rtype: Optional[ListNode] """ if list1 is None: return list2 elif list2 is None: return list1 elif list1.val < list2.val: list1.next = self.mergeTwoLists(list1.next, list2) return list1 else: list2.next = self.mergeTwoLists(list1, list2.next) return list2
2 两数相加
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。请你将两个数相加，并以相同形式返回一个表示和的链表。
方法一：对应位相加然后判断是否要进位，短的链表结束后，长的链表剩余部分同样要考虑进位，甚至于最后要多创建一个结点；
class Solution(object): def addTwoNumbers(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ flag = 0 list1, list2 = l1, l2 while True: val = (list1.val+list2.val+flag) % 10 flag = (list1.val+list2.val+flag) // 10 list1.val = val if list1.next==None or list2.next==None: break else:list1, list2= list1.next, list2.next #list1=list2:处理flag #list1>list2:继续处理剩余位 #list1<list2:转接到list2去，继续处理剩余位 if list1.next!=None or list2.next!=None: if list2.next != None: # list1<list2 list1.next = list2.next list1 = list1.next else: # list1>list2 list1 = list1.next while list1: # 继续处理剩余位 val = (list1.val+flag) % 10 flag = (list1.val+flag) // 10 list1.val = val if list1.next==None:break else: list1 = list1.next if flag: list1.next = ListNode(flag) # 处理进位 return l1方法二：在短链表的空缺位补0
class Solution(object): def addTwoNumbers(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ head = ListNode(0) #创建一个虚拟的头结点 p = head flag = 0 list1, list2 = l1, l2 while list1 or list2: if not list1:val1 = 0 else: val1 = list1.val list1 = list1.next if not list2:val2 = 0 else: val2 = list2.val list2 = list2.next val = (val1+val2+flag) % 10 flag = (val1+val2+flag) // 10 p.next = ListNode(val) p = p.next if flag:p.next = ListNode(flag) return head.next
19 删除链表的倒数第N个结点
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
方法一：两遍扫描，第一次统计长度，第二次删除结点；
注意：删除节点时一头一尾需要特殊考虑
class Solution(object): def removeNthFromEnd(self, head, n): """ :type head: ListNode :type n: int :rtype: ListNode """ cnt = 0 p = head while p: cnt += 1 p = p.next if cnt == n: return head.next else: i = 0 p = head for i in range(cnt-n-1): p = p.next if p.next.next == None:p.next = None else: p.next = p.next.next return head方法二：快慢指针 快指针比慢指针领先n步，这样当快指针到达链表结尾时，慢指针恰好指向倒数第n个结点；
class Solution: def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode: dummy = ListNode(0) dummy.next = head #step1: 快指针先走n步 slow, fast = dummy, dummy for _ in range(n): fast = fast.next #step2: 快慢指针同时走，直到fast指针到达尾部节点，此时slow到达倒数第N个节点的前一个节点 while fast and fast.next: slow, fast = slow.next, fast.next #step3: 删除节点，并重新连接 slow.next = slow.next.next return dummy.next
24 两两交换链表中的结点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
方法一：双指针
class Solution(object): def swapPairs(self, head): """ :type head: ListNode :rtype: ListNode """ if head == None: return head if head.next == None: return head head0 = ListNode(0) #创建一个虚拟的头结点 head0.next = head.next left, right = head, head.next while right: left.next = right.next #left指向了下一对的left,实际上需要指向下一对的right right.next = left if left.next == None:break elif left.next.next == None:break else: left.next, left = left.next.next, left.next #链接到下一对的right和切换left同步发生 right = left.next return head0.next实际交换两个结点，需要改变的是这两个结点的前置结点和后置结点一共四个结点的链接；
最后一个结点不需要保存；
class Solution: def swapPairs(self, head: ListNode) -> ListNode: # 已有的链表加一个头部 head node resultHead = ListNode() resultHead.next = head # curNode 遍历链表时用 curNode = resultHead # 开始遍历链表 while curNode and curNode.next and curNode.next.next: f = curNode s = curNode.next t = curNode.next.next # 两两交换链表结点 f.next = t s.next = t.next t.next = s # 标杆位后移2位 curNode = curNode.next.next return resultHead.next
25 K个一组翻转链表
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
用快慢指针截出k个结点，保留left的头结点old_head和right的尾结点old_tail，翻转k结点得到新的头结点new_head和尾结点new_tail，将原头链接到新头，新尾链接到原尾，再更新old_head/left/right即可；；
class Solution(object): def reverseKGroup(self, head, k): """ :type head: ListNode :type k: int :rtype: ListNode """ if head.next==None or k==1: return head p = ListNode(0) #创建一个虚拟的头结点 # p.next = head old_head, left, right = p, head, head while right: for _ in range(k-1): right = right.next if not right: return p.next old_tail = right.next new_head, new_tail = self.reverse(left, right) old_head.next = new_head new_tail.next = old_tail old_head, left, right = new_tail, old_tail, old_tail return p.next def reverse(self, head, tail): pre, cur = head, head.next while pre != tail: cur.next, cur, pre = pre, cur.next, cur #必须同步更新，不然更改指向后无法切换到下一结点（或者用一个新结点记录） return pre, head # 新头和新尾
138 随机链表的复制
给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。
step1：在原结点后面新建一个新结点，此时已复制好val和next；
step2：通过观察random发现，p.next.random = p.random.next 新p的随机指针指向原p的随机指针的下一结点，此时可以复制好random；
step3：分离链表
class Solution(object): def copyRandomList(self, head): """ :type head: Node :rtype: Node """ if not head:return None p = head while p: # 插入复制的新结点 p.next = Node(p.val, p.next, None) p = p.next.next p = head while p: # 设置random指针 if p.random: p.next.random = p.random.next p = p.next.next p = head head0 = Node(0) q = head0 while p: # 分离两链表 q.next = p.next q = q.next p.next = q.next # 不直接用p.next.next是因为要恢复原链表 p = p.next return head0.next方法二：存在一一对应关系，可以用哈希表存放；
class Solution(object): def copyRandomList(self, head): """ :type head: Node :rtype: Node """ if not head:return None hash = {} p = head while p: # hash[p] = Node(p.val, p.next, p.random) next和random需要下一轮指定，因为此时结点还未完全创建 hash[p] = Node(p.val) p = p.next p = head while p: if p.next: hash[p].next = hash[p.next] if p.random: hash[p].random = hash[p.random] p = p.next return hash[head]
148 排序链表
八大排序单开一篇文章讲
23 合并K个升序链表
学堆的基本操作了再补
146 LRU缓存
请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。
实现 LRUCache 类：
LRUCache(int capacity)以 正整数 作为容量capacity初始化 LRU 缓存int get(int key)如果关键字key存在于缓存中，则返回关键字的值，否则返回-1。void put(int key, int value)如果关键字key已经存在，则变更其数据值value；如果不存在，则向缓存中插入该组key-value。如果插入操作导致关键字数量超过capacity，则应该 逐出 最久未使用的关键字。
分析：需要读取缓存中关键字的值，用哈希；但哈希不记录缓存顺序，无法实现最久未使用关键字的逐出，用链表的指向；删除结点需要前一结点和后一结点的参与，用双向链表；
用哈希的键记录关键字，用哈希的值记录结点（结点值对应关键字和对应的值，同时拥有前后指针）
为什么要把关键字也放进结点的值？当删去结点时需要同步移出哈希表中的键
class DLinkedNode: def __init__(self, key=0, value=0): self.key = key self.value = value self.prev = None self.next = None class LRUCache: def __init__(self, capacity): self.cache = dict() self.head = DLinkedNode() # 使用伪头部和伪尾部节点 self.tail = DLinkedNode() self.head.next = self.tail self.tail.prev = self.head self.capacity = capacity self.size = 0 def get(self, key): if key not in self.cache: return -1 node = self.cache[key] # 如果key存在，先通过哈希表定位，再移到头部 self.moveToHead(node) return node.value def put(self, key, value): if key not in self.cache: node = DLinkedNode(key, value) # 如果key不存在，创建一个新的节点 self.cache[key] = node # 添加进哈希表 self.addToHead(node) # 添加至双向链表的头部 self.size += 1 if self.size > self.capacity: removed = self.removeTail() # 如果超出容量，删除双向链表的尾部节点 self.cache.pop(removed.key) # 删除哈希表中对应的项 self.size -= 1 else: node = self.cache[key] # 如果key存在，先通过哈希表定位，再修改value，并移到头部 node.value = value self.moveToHead(node) def addToHead(self, node): node.prev = self.head node.next = self.head.next self.head.next.prev = node self.head.next = node def removeNode(self, node): node.prev.next = node.next node.next.prev = node.prev def moveToHead(self, node): self.removeNode(node) self.addToHead(node) def removeTail(self): node = self.tail.prev self.removeNode(node) return nodePython中有哈希表与双向链表的数据结构 OrderedDict
