基础知识补充

单向链表结构：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._headwhile 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, headBwhile cur1:A.add(cur1)cur1 = cur1.nextwhile cur2:if cur2 in A:return cur2cur2 = cur2.nextreturn None

方法二：出现相交结点之后，所有结点相等，所以相交结点不可能出现在长链表的前(len1-len2)个结点中，只需要从短链表的头结点开始同步遍历判断是否相同即可；

class Solution:def getIntersectionNode(self, headA, headB):lenA, lenB = 0, 0A, B = headA, headB# 计算长度while A:A = A.nextlenA += 1while B:B = B.nextlenB += 1# 长链表先走，但不确定AB谁长，但实际上有至少一个循环不会执行A, B = headA, headBfor i in range(lenA-lenB):A = A.nextfor i in range(lenB-lenA):B = B.next# 两链表同步遍历while A and B and A != B:A = A.nextB = B.nextreturn A#虽然比方法一多遍历了一轮，但节省了内存开销

方法三：利用两链表的长度和相等；两指针分别从当前链表的头结点出发，移动到另一链表的尾结点，必定同时到达；而当出现相交结点时，从相交结点开始，两指针指向同一结点；

class Solution:def getIntersectionNode(self, headA, headB):A, B = headA, headBwhile not A == B:A = A.next if A else headBB = B.next if B else headAreturn A#两指针同时到达链表末尾时指向none，也会退出循环

206 反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

方法一：双指针 一个指向上一结点，一个指向当前结点，将当前结点的next指向上一结点即可；

class Solution(object):def reverseList(self, head):""":type head: ListNode:rtype: ListNode"""pre, cur = None, headwhile 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 headcur = self.reverseList(head.next)head.next.next = head               # 防止链表循环，需要将head.next设置为空head.next = Nonereturn 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  # 链表长度仅为1length, p = 0, head    # 记录长度while p:length += 1p = p.nextcnt = 0pre, cur = None, headwhile cnt < length//2:  # 反转一半cur.next, cur, pre = pre, cur.next, curcnt += 1if length%2:cur=cur.next # 长度为奇数时跳过# 此时pre为翻转的前一半的头结点，cnt为剩下一半的头结点while pre and cur:if pre.val != cur.val:return Falseelse:pre = pre.nextcur = cur.nextreturn True

 141 环形链表

给你一个链表的头节点 head ，判断链表中是否有环。如果链表中存在环 ，则返回 true 。 否则，返回 false 。环：如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。

方法一：用集合记录下每一个结点，若该结点在集合中出现过，则存在环；

class Solution(object):def hasCycle(self, head):""":type head: ListNode:rtype: bool"""H = set()p = headwhile p:if p in H:return Trueelse:H.add(p)p = p.nextreturn False

方法二（官方思路）：快慢指针-龟兔赛跑，每次移动龟跑一步兔跑两步，如果没有循环，当兔到达终点结束；如果有循环，兔会被循环卡死，到龟进入循环后，由于相对位移仅为一步，龟和兔必定会相遇；

class Solution(object):def hasCycle(self, head):""":type head: ListNode:rtype: bool"""slow, fast = head, head.nextwhile slow != fast:if fast == None or fast.next == None:return False  #fast跳了两步else:slow = slow.nextfast = fast.next.nextreturn 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, headwhile fast and fast.next:slow = slow.nextfast = fast.next.nextif slow == fast:idx1, idx2 = slow, headwhile idx1 != idx2:idx1 = idx1.nextidx2 = idx2.nextreturn idx1return 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 = headwhile list1 and list2:if list1.val < list2.val:p.next = list1list1 = list1.nextelse:p.next = list2list2 = list2.nextp = p.nextp.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 list2elif list2 is None: return list1elif list1.val < list2.val:list1.next = self.mergeTwoLists(list1.next, list2)return list1else: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 = 0list1, list2 = l1, l2while True:val = (list1.val+list2.val+flag) % 10flag = (list1.val+list2.val+flag) // 10list1.val = valif list1.next==None or list2.next==None: breakelse: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<list2list1.next = list2.nextlist1 = list1.nextelse:                  # list1>list2list1 = list1.nextwhile list1:                              # 继续处理剩余位val = (list1.val+flag) % 10flag = (list1.val+flag) // 10list1.val = valif list1.next==None:breakelse: list1 = list1.nextif 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 = headflag = 0list1, list2 = l1, l2while list1 or list2:if not list1:val1 = 0else:val1 = list1.vallist1 = list1.nextif not list2:val2 = 0else:val2 = list2.vallist2 = list2.nextval = (val1+val2+flag) % 10flag = (val1+val2+flag) // 10p.next = ListNode(val)p = p.nextif 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 = 0p = headwhile p:cnt += 1p = p.nextif cnt == n: return head.nextelse:i = 0p = headfor i in range(cnt-n-1):p = p.nextif p.next.next == None:p.next = Noneelse: p.next = p.next.nextreturn head

方法二：快慢指针   快指针比慢指针领先n步，这样当快指针到达链表结尾时，慢指针恰好指向倒数第n个结点；

class Solution:def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:dummy = ListNode(0)dummy.next = head #step1: 快指针先走n步slow, fast = dummy, dummyfor _ 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 headif head.next == None: return headhead0 = ListNode(0)  #创建一个虚拟的头结点head0.next = head.nextleft, right = head, head.nextwhile right:left.next = right.next        #left指向了下一对的left,实际上需要指向下一对的rightright.next = left    if left.next == None:breakelif left.next.next == None:breakelse: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 noderesultHead = ListNode()resultHead.next = head# curNode 遍历链表时用curNode = resultHead# 开始遍历链表while curNode and curNode.next and curNode.next.next:f = curNodes = curNode.nextt = curNode.next.next# 两两交换链表结点f.next = ts.next = t.nextt.next = s# 标杆位后移2位curNode = curNode.next.nextreturn 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 headp = ListNode(0)  #创建一个虚拟的头结点# p.next = headold_head, left, right = p, head, headwhile right:for _ in range(k-1):right = right.nextif not right: return p.next     old_tail = right.nextnew_head, new_tail = self.reverse(left, right)old_head.next = new_headnew_tail.next = old_tailold_head, left, right = new_tail, old_tail, old_tailreturn p.nextdef reverse(self, head, tail):pre, cur = head, head.nextwhile 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 Nonep = headwhile p:                 # 插入复制的新结点p.next = Node(p.val, p.next, None)p = p.next.nextp = headwhile p:                 # 设置random指针if p.random: p.next.random = p.random.nextp = p.next.nextp = headhead0 = Node(0)q = head0while p:                 # 分离两链表q.next = p.nextq = q.nextp.next = q.next      # 不直接用p.next.next是因为要恢复原链表p = p.nextreturn head0.next

方法二：存在一一对应关系，可以用哈希表存放；

class Solution(object):def copyRandomList(self, head):""":type head: Node:rtype: Node"""if not head:return Nonehash = {}p = headwhile p:# hash[p] = Node(p.val, p.next, p.random)  next和random需要下一轮指定，因为此时结点还未完全创建hash[p] = Node(p.val)p = p.nextp = headwhile p:if p.next: hash[p].next = hash[p.next]if p.random: hash[p].random = hash[p.random]p = p.nextreturn 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 = keyself.value = valueself.prev = Noneself.next = Noneclass LRUCache:def __init__(self, capacity):self.cache = dict()self.head = DLinkedNode()  # 使用伪头部和伪尾部节点  self.tail = DLinkedNode()self.head.next = self.tailself.tail.prev = self.headself.capacity = capacityself.size = 0def get(self, key):if key not in self.cache: return -1node = self.cache[key]      # 如果key存在，先通过哈希表定位，再移到头部self.moveToHead(node)return node.valuedef put(self, key, value):if key not in self.cache:node = DLinkedNode(key, value)   # 如果key不存在，创建一个新的节点 self.cache[key] = node        #  添加进哈希表self.addToHead(node)         # 添加至双向链表的头部self.size += 1if self.size > self.capacity:removed = self.removeTail()  # 如果超出容量，删除双向链表的尾部节点self.cache.pop(removed.key)  # 删除哈希表中对应的项self.size -= 1else:node = self.cache[key]    # 如果key存在，先通过哈希表定位，再修改value，并移到头部node.value = valueself.moveToHead(node)def addToHead(self, node):node.prev = self.headnode.next = self.head.nextself.head.next.prev = nodeself.head.next = nodedef removeNode(self, node):node.prev.next = node.nextnode.next.prev = node.prevdef moveToHead(self, node):self.removeNode(node)self.addToHead(node)def removeTail(self):node = self.tail.prevself.removeNode(node)return node

Python中有哈希表与双向链表的数据结构 OrderedDict