目录
一、学习视频
二、视频跟练
1.206. 反转链表
2.92. 反转链表 II
3.25. K 个一组翻转链表
三、课后习题
1.24. 两两交换链表中的节点
（1）循环两次
（2）直接反转
（3）递归
2.445. 两数相加 II
（1）迭代-原地修改-错误
（2）迭代-开新链表
（3）递归
（4）栈
3.2816. 翻倍以链表形式表示的数字
（1）栈-原地-三次遍历
（2）栈-新建链表-两次遍历
（3）反转链表-原地修改-两次遍历
（4）一次遍历
（5）一次遍历2
一、学习视频
【反转链表】 https://www.bilibili.com/video/BV1sd4y1x7KN/?share_source=copy_web&vd_source=dc0e55cfae3b304619670a78444fd795
二、视频跟练
1.206. 反转链表
来自视频
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:pre = Nonecur = headwhile cur:nxt = cur.nextcur.next = prepre = curcur = nxt return pre2.92. 反转链表 II
来自视频
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:dummy = ListNode(next = head) # 哨兵节点p0 = dummy# 到达反转开始位置for _ in range(left - 1):p0 = p0.next# 开始反转pre, cur = None, p0.nextfor _ in range(right - left + 1):nxt = cur.nextcur.next = prepre = curcur = nxt# 连接p0.next.next = curp0.next = prereturn dummy.next3.25. K 个一组翻转链表
来自视频
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def reverseKGroup(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:# 获取链表长度n = 0cur = headwhile cur:n += 1cur = cur.nextdummy = ListNode(next = head) # 哨兵节点pre = Nonecur = headp0 = dummywhile n >= k:n -= kfor _ in range(k):nxt = cur.next cur.next = prepre = curcur = nxtnxt = p0.next # 这里是关键，p0.next是旋转后的cur的前一位p0.next.next = curp0.next = prep0 = nxt# pre = nxt # 这里对pre进行更新'''这里为什么可以不用更新pre，当未更新时，cur指向pre时，cur是p0的下一个节点当进行拼接时，p0.next.next = cur，会改变当时cur的那一条指向所有更不更新没有关系'''return dummy.next三、课后习题
1.24. 两两交换链表中的节点
（1）循环两次
k个节点循环的做法，此时k=2。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:dummy = ListNode(next = head)p0 = dummy # p0和dummy最开始指向同一个节点cur = headpre = Nonewhile cur and cur.next:for _ in range(2):nxt = cur.nextcur.next = prepre = curcur = nxtnxt = p0.nextp0.next.next = curp0.next = prep0 = nxtreturn dummy.next（2）直接反转
两个为一组直接进行反转连接
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:# 直接交换dummy = ListNode(next = head)p0 = dummypre = headwhile pre and pre.next:cur = pre.nextnxt = cur.nextp0.next = curcur.next = prepre.next = nxtp0 = prepre = nxtreturn dummy.next（3）递归
来自官方题解（. - 力扣（LeetCode））。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:# 递归if not head or not head.next:return headnewhead = head.next # 第二个节点p2# 将后面的节点（第二个后的）进行反转，反转后返回的部分连接在第一个节点p1的后面head.next = self.swapPairs(newhead.next)newhead.next = head #p2后面接p1，反转return newhead2.445. 两数相加 II
（1）迭代-原地修改-错误
当l1，l2遍历完但有进位时，会缺少节点，最好还是使用开新的储存空间的方法。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:# 迭代def transform(head: Optional[ListNode]) -> Optional[ListNode]:pre = Nonecur = headwhile cur:nxt = cur.nextcur.next = prepre = curcur = nxtreturn prel1 = transform(l1)l2 = transform(l2)pre1 = Nonecur1, cur2 = l1, l2# 假定l1长，将所有运算结果储存在l1上num = 0while cur1 and cur2:# 数字操作x = cur1.val + cur2.val + numnum = x // 10cur1.val = x % 10# 反转操作nxt = cur1.nextcur1.next = pre1pre1 = cur1cur1 = nxt# 迭代cur2 = cur2.nextif not cur1:cur1 = cur2while cur1:# 数字操作x = cur1.val + numnum = x // 10cur1.val = x % 10# 反转操作nxt = cur1.nextcur1.next = pre1pre1 = cur1cur1 = nxtreturn pre1（2）迭代-开新链表
来自灵神题解（. - 力扣（LeetCode））。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:pre = Nonecur = headwhile cur:nxt = cur.nextcur.next = prepre = curcur = nxtreturn predef addTwo(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:cur = dummy = ListNode()carry = 0 # 进位while l1 or l2 or carry:if l1: carry += l1.valif l2: carry += l2.valcur.next = ListNode(carry % 10)cur = cur.nextcarry //= 10 # 注意更新if l1: l1 = l1.nextif l2: l2 = l2.nextreturn dummy.nextdef addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:# 迭代-开新链表l1 = self.reverseList(l1)l2 = self.reverseList(l2)newList = self.addTwo(l1, l2)return self.reverseList(newList)（3）递归
来自灵神题解。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:if not head or not head.next:return headnewhead = self.reverseList(head.next) # 此时的头节点为原来链表的最后一个节点# 反转操作，此时相当于是对尾操作，与头节点无关head.next.next = headhead.next = None # 尾节点return newheaddef addTwo(self, l1: Optional[ListNode], l2: Optional[ListNode], carry = 0) -> Optional[ListNode]:if not l1 and not l2:return ListNode(carry) if carry else Noneif not l1:l1, l2 = l2, l1 # 保证l1是非空的，便于返回carry += l1.val + (l2.val if l2 else 0)l1.val = carry % 10l1.next = self.addTwo(l1.next, l2.next if l2 else None, carry // 10)return l1def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:# 递归l1 = self.reverseList(l1)l2 = self.reverseList(l2)newList = self.addTwo(l1, l2)return self.reverseList(newList)（4）栈
来自官方题解（. - 力扣（LeetCode））。
先全部入栈，弹出一个运算一次头插一次。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:# 栈，运算顺序，后进先出s1, s2 = [], []# 全部入栈while l1:s1.append(l1.val)l1 = l1.nextwhile l2:s2.append(l2.val)l2 = l2.nextdummy = ListNode()carry = 0while s1 or s2 or carry:s = (0 if not s1 else s1.pop()) + (0 if not s2 else s2.pop()) + carrycarry, val = divmod(s, 10)dummy.next = ListNode(val, dummy.next) # 头插法return dummy.next3.2816. 翻倍以链表形式表示的数字
（1）栈-原地-三次遍历
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:# 栈-原地-三次遍历# 逆序运算可以使用栈start, end = [], [] # 运算，更新均使用栈cur = head# 入栈while cur:start.append(cur.val)cur = cur.next# 运算carry = 0while start:carry += start.pop() * 2end.append(carry % 10)carry //= 10# 更新答案dummy = ListNode(val = carry if carry else 0, next = head)cur = headwhile cur:cur.val = end.pop()cur = cur.nextreturn dummy if dummy.val else dummy.next
（2）栈-新建链表-两次遍历
又用到了栈，又用到了头插法，又新建节点，效率不是很高。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:# 栈-新建链表-两次遍历start = []cur = head# 入栈while cur:start.append(cur.val)cur = cur.next# 运算carry = 0dummy = ListNode()while start:carry += start.pop() * 2dummy.next = ListNode(val = carry % 10, next = dummy.next)carry //= 10if carry: dummy.next = ListNode(val = carry, next = dummy.next)return dummy.next（3）反转链表-原地修改-两次遍历
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:# 反转链表-原地修改-两次遍历# 反转链表cur = headpre = Nonewhile cur:nxt = cur.nextcur.next = prepre = curcur = nxtcarry = 0cur = prepre = Nonewhile cur:# 运算carry += cur.val * 2cur.val = carry % 10carry //= 10# 反转nxt = cur.nextcur.next = prepre = curcur = nxtdummy = ListNode(next = pre)if carry: dummy.next = ListNode(val = carry, next = dummy.next)return dummy.next（4）一次遍历
来自灵神题解（. - 力扣（LeetCode））。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:# 一次遍历# 总结规律if head.val > 4:# 添加一位head = ListNode(0, head)cur = headwhile cur:cur.val = cur.val * 2 % 10if cur.next and cur.next.val > 4:cur.val += 1cur = cur.nextreturn head（5）一次遍历2
来自题解（. - 力扣（LeetCode））。和（4）的解法道理是一样的，都是根据数值的范围确定只能进位一次。（4）是从上节点的角度，而（5）是从下节点的角度。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:def doubleIt(self, head: Optional[ListNode]) -> Optional[ListNode]:# 一次遍历2dummy = ListNode(next = head)pre = dummycur = headwhile cur:newVal = cur.val * 2pre.val += newVal // 10cur.val = newVal % 10pre = curcur = cur.nextreturn dummy if dummy.val else dummy.next完
感谢你看到这里！一起加油吧！
)
)
