力扣21~25题
21题（简单）：
分析：
按要求照做就好了，这种链表基本操作适合用c写，python用起来真的很奇怪
python代码：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
if list1 and list2:
p=ListNode()
head=p
while 1:
if list1==None:
p.next=list2
break
elif list2==None:
p.next=list1
break
else:
if list1.val>list2.val:
p.next=list2
p=p.next
list2=list2.next
else:
p.next=list1
p=p.next
list1=list1.next
return head.next
else:
return list1 if list1 else list2
22题（中等）
分析：
这个题明显要用递归才行，如果用循环真不好做，我们每次确定第n位，但是n+1位有2种（或一种情况），这个要丢进数组里面，下一次循环要对数组每一个进行进一步操作，能做但是很麻烦，我们知道循环适合线性的东西，没必要在非线性的情况下使用循环，除非特别需要，东西我觉得还是用着适合的地方好
python代码：
class Solution:
def generateParenthesis(self, n: int) -> List[str]:
res=[]
def backcall_track(s,left,right):
if left==right:
if left!=n:
s+='('
backcall_track(s,left+1,right)
else:
res.append(s)
return
else:
if left<n:
backcall_track(s+'(',left+1,right)
if right<n:
backcall_track(s+')',left , right+1)
backcall_track('',0,0)
return res
23题（困难）：
分析：
真不配这个难度，因为这个直接暴力求解都行，和第一个（21题）没区别，python没有指针，初始化感觉挺麻烦，你看了我代码就发现，我的head第一个往往都是空，返回head.next，因为我不想浪费空间重新拿创建，所以我更倾向于用它给的空间，这样看起来说实话有点别扭。但是第一个的赋值要在我们弄或者建立索引单独弄也别扭，以后再补上c++的吧
python代码
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
p=ListNode()
res=p
if len(lists)==0:
return None
while 1:
k=0
for i in range(len(lists)):
if lists[k]==None:
k=i
if lists[i] and lists[i].val<lists[k].val:
k=i
if lists[k]==None:
break
print(k)
p.next=lists[k]
p=p.next
lists[k]=lists[k].next
return res.next if res.next else None
24题：
分析：
链表基础操作
python代码：
# 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 head==None:
return None
p=head
res=None
if p.next!=None:
res=p.next
q=p.next.next
p.next.next=p
p.next=q
else:
return head
while p.next!=None:
if p.next.next!=None:
q=p.next.next.next
p.next.next.next=p.next
p.next=p.next.next
p.next.next.next=q
p=p.next.next
else:
break
return res
题25（困难）：
分析：
有意思，但是难度不配困难。思路其实挺清晰，我们知道链表时候插入数据但是不适合查找数据，本题因为要交换k个数据就说明一定要查找数据，因为你不知道要找第几个，而是要传入k，这个时候肯定要寻求数组的帮助，我们定义一个长度为k的数组，每次拿k个，这样我们要哪个就方便了
python代码：
# 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]:
res=ListNode(0,head)
p=res
while 1:
node_list=[]
flag=1
q=p
for i in range(k):
if q.next==None:
flag=0
break
else:
q=q.next
node_list.append(q)
last_node=q.next
if flag:
for i in range(k):
p.next=node_list[k-i-1]
p=p.next
p.next=last_node
else:
break
return res.next
总结：
我发现我都注释没怎么写过，导致写得时候思路没有特别清晰，所以要开始写注释了