剑指offer刷题记录
LeetCode上的剑指offer题
刷题ing…
3.数组中重复的数字
#遇见了得先问面试官时间和空间复杂度的要求
#1.排序+一个下一个
#时间O(nlogn) 空间O(1)
class Solution:
def findRepeatNumber(self, nums: List[int]) -> int:
nums.sort()
for i in range(len(nums)-1):
if nums[i]==nums[i+1]:
return nums[i]
#2.hash
#时间O(n),空间O(n)
#Python中的成员资格(membership)检查运算“in”，在列表(list)中遍历成员，时间复杂度为O(N); 在字典(dict)中, 时间复杂度为O(N)
class Solution:
def findRepeatNumber(self, nums: List[int]) -> int:
memo = dict()
for num in nums:
if not memo.__contains__(num):
memo[num]=1
else:
return num
#3.原地哈希
#时间O(n),空间O(1)
class Solution:
def findRepeatNumber(self, nums: List[int]) -> int:
n = len(nums)
#把原列表当哈希再用
for i in range(n):
while i!= nums[i]:
if nums[i] == nums[nums[i]]:
return nums[i]
temp = nums[i]
nums[i],nums[temp]= nums[temp],nums[i]
4.二维数组中的查找
#1.视作BST_递归
#从右上角开始比较，比它大就往下数一行，比它小就往左数一列
class Solution:
def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
if not matrix:
return False
self.target = target
self.res = False
self.helper(0,len(matrix[0])-1,matrix)
return self.res
def helper(self,i,j,matrix):
if i<len(matrix) and j>=0:
if matrix[i][j]==self.target:
self.res = True
if matrix[i][j]>self.target:
self.helper(i,j-1,matrix)
else:
self.helper(i+1,j,matrix)
#2.视作BST_迭代
class Solution:
def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
if not matrix:
return False
n = len(matrix)
m = len(matrix[0])
i = 0
j = m-1
while i<len(matrix) and j>=0:
if matrix[i][j]==target:
return True
elif matrix[i][j]>target:
j-=1
else:
i+=1
return False
#3.暴力_内循环二分查找剪枝
class Solution:
def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
#暴力，内循环用二分查找
if not matrix:
return False
n = len(matrix)
m = len(matrix[0])
def helper(line,i,j,target):
if i>j:
return False
mid = (i+j)//2
if line[mid]==target:
return True
elif line[mid]>target:
return helper(line,i,mid-1,target)
else:
return helper(line,mid+1,j,target)
for i in range(n):
if helper(matrix[i],0,m-1,target):
return True
return False
5.替换空格
#1.一般py字符串操作
class Solution:
def replaceSpace(self, s: str) -> str:
return s.replace(' ','%20')
#2.一般遍历，外部空间使用
class Solution:
def replaceSpace(self, s: str) -> str:
ans = ''
for l in s:
if l==' ':
ans+='%20'
else:
ans+=l
return ans
6.从尾到头打印链表
#1.常规压栈
class Solution:
def reversePrint(self, head: ListNode) -> List[int]:
#因为数组返回，可以直接压栈
p = head
stack = []
while p:
stack.append(p.val)
p = p.next
return stack[::-1]
#2.递归栈
class Solution:
def reversePrint(self, head: ListNode) -> List[int]:
if not head:
return []
else:
return self.reversePrint(head.next) + [head.val]
#3.无栈，两次遍历
class Solution:
def reversePrint(self, head: ListNode) -> List[int]:
p = head
cnt=0
while p:
cnt+=1
p = p.next
p = head
ans = [0]*cnt
while cnt>0:
ans[cnt-1]=p.val
cnt -= 1
p = p.next
return ans
7.重建二叉树
#1.递归
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
def helper(preleft,preright,inleft,inright,preorder,inorder):
if preleft>preright:
return
root = TreeNode(preorder[preleft])
p = inleft
while inorder[p]!=root.val:
p+=1
left = p-inleft
root.left = helper(preleft+1,preleft+left,inleft,inleft+left-1,preorder,inorder)
root.right = helper(preleft+left+1,preright,inleft+left+1,inright,preorder,inorder)
return root
return helper(0,len(preorder)-1,0,len(inorder)-1,preorder,inorder)
#2.迭代
'''
看第i个元素位于当前root的left还是right就看中序有无遍历到root，未遍历到就是在root左侧，左子树，反之右子树
使用栈保存遍历过的节点。初始时令中序遍历的指针指向第一个元素，遍历前序遍历的数组，如果前序遍历的元素不等于中序遍历的指针指向的元素，则前序遍历的元素为上一个节点的左子节点。如果前序遍历的元素等于中序遍历的指针指向的元素，则正向遍历中序遍历的元素同时反向遍历前序遍历的元素，找到最后一次相等的元素，将前序遍历的下一个节点作为最后一次相等的元素的右子节点。其中，反向遍历前序遍历的元素可通过栈的弹出元素实现。
'''
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder:
return None
root = TreeNode(preorder[0])
length = len(preorder)
stack = []
stack.append(root)#节点入栈
index = 0
for i in range(1, length):
preorderval = preorder[i]
node = stack[-1]
if node.val != inorder[index]: # 每次比较栈顶元素和inorder[index]
node.left = TreeNode(preorderval)
stack.append(node.left)
else:
while stack and stack[-1].val == inorder[index]:# 栈顶元素等于inorder[index],弹出；并且index += 1
node = stack[-1]
stack.pop()
index += 1
node.right = TreeNode(preorderval)
stack.append(node.right)
return root
9.用两个栈实现队列
#1.脑子一热只写了一个栈
class CQueue:
def __init__(self):
self.deque = []
def appendTail(self, value: int) -> None:
self.deque.append(value)
def deleteHead(self) -> int:
if len(self.deque)==0:
return -1
else:
ans = self.deque[0]
self.deque = self.deque[1:]
return ans
#2.双栈
'''
其中 stack1 用于存储元素，stack2 用于辅助操作
若stack1非空而stack2空，则将1清空入栈2，2用于辅助pop
'''
class CQueue:
def __init__(self):
self.stack1 = []
self.stack2 = []
def appendTail(self, value: int) -> None:
self.stack1.append(value)
def deleteHead(self) -> int:
if self.stack2:#平时就从栈2pop反序的，就是FIFO了
return self.stack2.pop()
elif not self.stack1:#两个栈都空了，没得吐了
return -1
else:#栈2空了，栈1数据倾倒进去
while self.stack1:#栈尾变栈顶，反向堆到stack2里边
self.stack2.append(self.stack1.pop())
return self.stack2.pop()
10. 斐波那契数列
#1.暴力
class Solution:
def fib(self, n: int) -> int:
a0 = 0
a1 = 1
if n == 0:
return 0
if n==1:
return 1
ans = 0
for i in range(n-1):
ans = a0+a1
a0 = a1
a1 = ans
return ans % 1000000007
#2.暴力记忆化递归
'''
在递归法的基础上，新建一个长度为 nn 的数组，用于在递归时存储 f(0)f(0) 至 f(n)f(n) 的数字值，重复遇到某数字则直接从数组取用，避免了重复的递归计算。
'''
class Solution:
@lru_cache(None)
def fib(self, n: int) -> int:
if n <2:
return n
return (self.fib(n-1)+self.fib(n-2))% 1000000007
11-2.青蛙跳台阶问题
#1.dp
class Solution:
def numWays(self, n: int) -> int:
#dpdp？？？？
if n<2:
return 1
dp = [0]*(n+1)
dp[0]=1
dp[1]=1
for i in range(2,n+1):
dp[i] = dp[i-1]+dp[i-2]
return dp[-1]%1000000007
#2.dp空间优化
class Solution:
def numWays(self, n: int) -> int:
#dpdp空间优化
if n<2:
return 1
pre0=1
pre1=1
for i in range(2,n+1):
ans = pre0+pre1
pre0 = pre1
pre1 = ans
return ans%1000000007
11.旋转数组的最小数字
#1.一次遍历找转折点
class Solution:
def minArray(self, numbers: List[int]) -> int:
for i in range(len(numbers)-1):
if numbers[i+1]<numbers[i]:
return numbers[i+1]
else:
return numbers[0]
#2.二分_要注意边界条件
class Solution:
def minArray(self, numbers: List[int]) -> int:
l = 0
r = len(numbers)-1
while l<r:
mid = (r-l)//2+l
if numbers[mid]<numbers[r] and numbers[mid]<=numbers[l]:
#右半边有序,转折点确定在左边
r=mid
elif numbers[mid]>=numbers[l] and numbers[mid]>numbers[r]:
#左半有序，确定转折点在右，mid肯定不是
l=mid+1
else:#完全有序数列
r-=1
return numbers[l]
12.矩阵中的路径
#1.边界条件十分痛苦DFS
class Solution:
def exist(self, board: List[List[str]], word: str) -> bool:
#dfs
def dfs(board,i,j,cnt,word):
m = len(board)
n = len(board[0])
if cnt==len(word):
return True
if i<0 or i>=m or j<0 or j>=n or board[i][j]!=word[cnt]:
return False
board[i][j]='*'
for x,y in [(0,1),(0,-1),(1,0),(-1,0)]:
idx1 = i+x
idx2 = j+y
#print(board[idx1][idx2],word[cnt])
if dfs(board,idx1,idx2,cnt+1,word):
return True
#这个进入点没能找到，返回来的时候cnt可以作为标识
board[i][j] = word[cnt]
return False
m = len(board)
n = len(board[0])
if m<1 and n<1 and not word:
return False
for i in range(m):
for j in range(n):
if dfs(board,i,j,0,word):
return True
return False
13.机器人的运动范围
#1.dfs
class Solution:
def movingCount(self, m: int, n: int, k: int) -> int:
self.visited = [[False]*n for _ in range(m)]
return self.dfs(0,0,m,n,k)
def dfs(self,i,j,m,n,k):
if (i<0 or i>=m or j<0 or j>=n or (i//10+i%10+j//10+j%10)>k or self.visited[i][j]):
return 0
self.visited[i][j] = True
return self.dfs(i+1,j,m,n,k)+self.dfs(i-1,j,m,n,k)+self.dfs(i,j+1,m,n,k)+self.dfs(i,j-1,m,n,k)+1
14.剪绳子
#1.dpdp
class Solution:
def cuttingRope(self, n: int) -> int:
#dpdp
dp = [0]*(n+1)
dp[1]=1
for i in range(2,n+1):
for j in range(1,i):
#j是减下来的长度,dp记录当前长度最大切割乘积
#max(dp[j],j)决定用切下来的那段再切切还是就不切了比较长
#和dpi比较看需不需要在长度j这里切割
dp[i] = max(max(dp[j],j)*(i-j),dp[i])
return dp[-1]
#2.奇妙数学法
#推导——尽可能将n长度三等分
'''
利用均值不等式求出乘积最大值 L(m)=(n/m)^m 对此式求导（可利用对数法），可以证明当 m=n/e 时，乘积取最大，此时每段绳子的长度为 n/(n/e)=e，自然对数e的值为2.718，接近3
'''
class Solution:
def cuttingRope(self, n: int) -> int:
if n <= 3: return n - 1
a, b = n // 3, n % 3
if b == 0: return int(math.pow(3, a))
if b == 1: return int(math.pow(3, a - 1) * 4)
return int(math.pow(3, a) * 2)
14-2.大数剪绳子，取模防溢出
class Solution:
def cuttingRope(self, n: int) -> int:
#dpdp
dp = [0]*(n+1)
dp[1]=1
for i in range(2,n+1):
for j in range(1,i):
#j是减下来的长度,dp记录当前长度最大切割乘积
#max(dp[j],j)决定用切下来的那段再切切还是就不切了比较长
#和dpi比较看需不需要在长度j这里切割
dp[i] = max(max(dp[j],j)*(i-j),dp[i])
#大数的话在这一步就会溢出
return dp[-1]% 1000000007
15.二进制中1的个数
#1.位运算1
class Solution:
def hammingWeight(self, n: int) -> int:
cnt=0
while n!=0:
'''
1100：减一后变为1011
1100&1011=1000
n与减1后的数做与运算会减少原本n的1个数
即有几个1就可以做几次与运算
'''
cnt+=1
n&=n-1
return cnt
#2.位运算2
class Solution:
def hammingWeight(self, n: int) -> int:
cnt=0
while n!=0:
'''
有符号右移>>（若正数,高位补0,负数,高位补1）
无符号右移>>>(不论正负,高位均补0)
然而py没有无符号右移
'''
cnt+=n&1
n>>=1
return cnt
16. 数值的整数次方
#1.迭代快速幂，非位运算考量，其实位运算也可
class Solution:
def myPow(self, x: float, n: int) -> float:
#奇数、偶数、负数
#偶数的话直接翻倍，奇数的话在外边存储一倍
#一般快速幂
if n==0:
return 1
if n==1:
return x
if n==-1:
return 1/x
m = abs(n)
tmp = []
while m>1:
if m%2==0:
x*=x
m=m//2
else:
tmp.append(x)
x*=x
m=m//2
while tmp:
x*=tmp.pop()
if n<0:
return 1/x
return x
#2.递归
class Solution:
def myPow(self, x: float, n: int) -> float:
if n == 0:
return 1
if n < 0:
return 1 / self.myPow(x, -n)
# 如果是奇数
if n & 1:
return x * self.myPow(x, n - 1)
return self.myPow(x * x, n // 2)
17.打印从1到最大的n位数
#1.普通
class Solution:
def printNumbers(self, n: int) -> List[int]:
return list(range(1,10**n))
#2.字符串，不过还不是大数，毕竟int(''.join(tmp))
class Solution:
def printNumbers(self, n: int) -> List[int]:
res = []
tmp = ['']*n
def helper(idx):
if idx==n:
res.append(int(''.join(tmp)))
return
for i in range(10):
tmp[idx]=chr(ord('0')+i)
helper(idx+1)
helper(0)
return res[1:]
#3.大数-string操作
class Solution:
def printNumbers(self, n: int) -> List[int]:
def helper(cur_s: str, place: int, increas: int): # place = -1, -2, -3
if abs(place) > len(cur_s):
#倒着数位数，用abs
cur_s = '1' + cur_s
#进位
return cur_s
else:
if cur_s[place] != '9':
if place == -1:
cur_s = cur_s[:place] + str(int(cur_s[place]) + 1)
else:
cur_s = cur_s[:place] + str(int(cur_s[place]) + 1) + cur_s[place+1:]
return cur_s
else:
#进位时place所在位位清0
if place == -1:
cur_s = cur_s[:place] + '0'
else:
cur_s = cur_s[:place] + '0' + cur_s[place+1:]
return helper(cur_s, place-1, 1)
res = []
cur_s = '0'
while len(cur_s) <= n:
res.append(int(cur_s))
cur_s = helper(cur_s, -1, 1)#这样即便是刚进位的2位数，也照样从个位数开始增加返回
return res[1:]
18.删除链表的节点
#1.非空哑结点和一遍遍历
#边界值非空判断其实也可以，但是双指针优雅一点
class Solution:
def deleteNode(self, head: ListNode, val: int) -> ListNode:
dummy = ListNode(0)
dummy.next = head
p = dummy
while p and p.next:
if p.next.val==val:
p.next = p.next.next
break
p = p.next
return dummy.next
19.正则表达式匹配(hard)
假设主串为 AA，模式串为 BB 从最后一步出发，需要关注最后进来的字符。假设 AA 的长度为 nn ，BB 的长度为 mm ，关注正则表达式 BB 的最后一个字符是谁，它有三种可能，正常字符、*∗ 和 .（点），那针对这三种情况讨论即可，如下：
如果 B 的最后一个字符是正常字符，那就是看 A[n-1]是否等于 B[m−1]，相等则看A0…n−2与B0…m−2，不等则是不能匹配，这就是子问题。
如果 B 的最后一个字符是.，它能匹配任意字符，直接看A 0…n−2与B 0…m−2
此时：f[i][j]=f[i−1][j−1]
如果 B 的最后一个字符是它代表 B[m-2]=cB[m−2]=c 可以重复0次或多次，它们是一个整体 c
情况一：A[n-1] 是 0 个 c，B 最后两个字符废了，能否匹配取决于A0…n−1 和B0…m−3是否匹配
情况二：A[n-1]是多个 c 中的最后一个（这种情况必须 A[n-1]=c 或者 c=’.’），所以 A 匹配完往前挪一个，B继续匹配，因为可以匹配多个，继续看A0…n−2和 B_{0…m-1}B0…m−1是否匹配。
1：直接砍掉正则串的后面两个， f[i][j] = f[i][j-2]
2：正则串不动，主串前移一个，f[i][j] = f[i-1][j]
dp边界：
空串和空正则是匹配的，f[0][0] = truef[0][0]=true
空串和非空正则，不能直接定义 true 和 false，必须要计算出来。
非空串和空正则必不匹配，f[1][0]=…=f[n][0]=false
#1.dpdp
class Solution:
def isMatch(self, s: str, p: str) -> bool:
#竟然是dp
lenp = len(p)
lens = len(s)
dp = [[False]*(lenp+1) for _ in range(lens+1)]
dp[0][0]=True
for j in range(1,lenp+1):
if p[j-1]=='*':
dp[0][j]=dp[0][j-1] or dp[0][j-2]#空串和非空正则，不能直接定义 true 和 false，必须要计算出来。
for i in range(1,lens+1):
for j in range(1,lenp+1):
if s[i-1]==p[j-1] or p[j-1]=='.':
dp[i][j]=dp[i-1][j-1]#p和s当前字符匹配，进到下一字符
elif p[j-1]=='*':
if s[i-1]==p[j-2] or p[j-2]=='.':#看再往前一个
#当前字符和前一个字符是匹配的
dp[i][j] = dp[i][j-2] or dp[i][j-1] or dp[i-1][j]#true/false传递
#1）删除前一个字符 dp[i][j-2]
#2）保留前一个字符 dp[i][j-1]
#3）复制前一个字符 dp[i-1][j]
else:
#尾上2个p的字符废了,只能删除字符
dp[i][j] = dp[i][j-2]
return dp[-1][-1]
#2.递归
class Solution:
def isMatch(self, s: str, p: str) -> bool:
def match(s, p, i, j):
if j == len(p): return i == len(s)#全空True,只有正则空False，若两个指针都进行到头True
flag = (i != len(s) and (s[i] == p[j] or p[j] == "."))
if j < len(p) - 1 and p[j+1] == "*":
#flag==T，后者为为情况1or情况2；
return flag and match(s, p, i+1, j) or match(s, p, i, j+2)
else:#当前不是*，f[i][j]=f[i−1][j−1]
return flag and match(s, p, i+1, j+1)
return match(s,p,0,0)
#3.递归清晰版
class Solution:
def isMatch(self, s: str, p: str) -> bool:
if not p: return not s
first_match = bool(s) and p[0] in (".", s[0])
if len(p) >= 2 and p[1] == "*":
if first_match:
return self.isMatch(s[1:], p) or self.isMatch(s, p[2:])
return self.isMatch(s, p[2:])
return first_match and self.isMatch(s[1:], p[1:])
#4.Py正则
class Solution:
def isMatch(self, s: str, p: str) -> bool:
return re.fullmatch(p, s) != None
20.表示数值的字符串(hard)
#1.把输入拆分改造成isnumeric可以判断的程度，看按decimal格式拆分的部分是否都由数字组成
class Solution:
def isNumber(self, s: str) -> bool:
'''
空格只能出现在首尾，出现在中间一定是非法的。
正负号只能出现在两个地方，第一个地方是数字的最前面，表示符号。
第二个位置是e后面，表示指数的正负。如果出现在其他的位置一定也是非法的。
e只能出现一次，并且e之后一定要有数字才是合法的，123e这种也是非法的。
小数点，由于e之后的指数一定是整数，所以小数点最多只能出现一次，并且一定要在e之前。
所以如果之前出现过小数点或者是e，再次出现小数点就是非法的。
'''
s = s.strip() #去掉两端的空白符
if not s :
return False
else:
if s[0] in ['+', '-']:
#去掉正负号
s = s[1:]
if 'e' in s:
temp_list = s.split('e')
if len(temp_list) > 2:
#字符串s中含有多于一个的’e‘,返回False
return False
temp_list[0] = temp_list[0].replace('.', '', 1) #去掉e前面的字符串中的'.',只进行一次，还有就是有多个'.'
if len(temp_list[1]) > 0 and temp_list[1][0] in ['+', '-']:
# 去掉e后面字符串中的'+'或者'-'，仅去掉一次，还有就是有多个'+', '-'
temp_list[1] = temp_list[1].replace(temp_list[1][0], '', 1)
if temp_list[0].isnumeric() and temp_list[1].isnumeric():
return True
return False
else: # s中不含'e'
s = s.replace('.', '', 1)
if s.isnumeric():
return True
return False
#2.确定有限自动机DFA
#参考：https://leetcode-cn.com/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/solution/que-ding-you-xian-zi-dong-ji-dfa-by-justyou/
class Solution:
def isNumber(self, s: str) -> bool:
if not s:
return False
根据有限状态的图来建立的状态跳转表格
transTable = [
[1,2,7,-1,-1,0],
[-1,2,7,-1,-1,-1],
[-1,2,3,4,-1,9],
[-1,3,-1,4,-1,9],
[6,5,-1,-1,-1,-1],
[-1,5,-1,-1,-1,9],
[-1,5,-1,-1,-1,-1],
[-1,8,-1,-1,-1,-1],
[-1,8,-1,4,-1,9],
[-1,-1,-1,-1,-1,9]
]
cols = {
"sign":0,
"number":1,
".":2,
"exp":3,
"other":4,
"blank":5
}
def get_col(c):
#做判断
if c.isdigit():return 'number'
elif c in {'+','-'}:return 'sign'
elif c == '.':return '.'
elif c in {'E','e'}:return 'exp'
elif c == ' ':return 'blank'
else:return 'other'
legal_state = {2,3,5,8,9}#结束状态
'''
中途遇到空格转到9，若后边还有别的直接就-1out，
'''
state = 0
for c in s:
state = transTable[state][cols[get_col(c)]]#结合当前的状态和当前的字符来跳转状态
if state == -1:
return False#没能跳转出去
return True if state in legal_state else False
21.调整数组顺序使奇数位于偶数前面
#1.暴力
class Solution:
def exchange(self, nums: List[int]) -> List[int]:
left = []
right = []
for i in range(len(nums)):
if nums[i]%2==0:
right.append(nums[i])
else:
left.append(nums[i])
return left+right
#2.快排双指针+swap
class Solution:
def exchange(self, nums: List[int]) -> List[int]:
#快排的双指针妙用
l = 0
r = len(nums)-1
while l<r:
while l<r and nums[r]%2==0:
r-=1
#直到指针对撞或者找到右边第一个奇数停止
while l<r and nums[l]%2!=0:
l+=1
#直到指针对撞或者找到左边第一个偶数停止
nums[l],nums[r]=nums[r],nums[l]#swap
l+=1
r-=1
return nums
#3.快慢双指针
class Solution:
def exchange(self, nums: List[int]) -> List[int]:
#快排的双指针妙用
low = 0
fast = 0
while fast<len(nums):
if nums[fast]%2!=0:
nums[low],nums[fast]=nums[fast],nums[low]
low+=1
fast+=1
return nums
22.链表中倒数第k个节点
#1.两次遍历法
class Solution:
def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
p = head
cnt = 0
while p:
cnt+=1
p = p.next
cnt-=k
p = head
while cnt:
p = p.next
cnt-=1
return p
#2.两个指针法
class Solution:
def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
pre = head
cur = head
cnt = 1
while cnt<k:
cnt+=1
cur = cur.next
while cur.next:
pre = pre.next
cur = cur.next
return pre
24.反转链表
#全文背诵
#1.迭代
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if not head:
return None
pre = None
while head:
next = head.next
head.next = pre
pre = head
head = next
return pre
#2.递归
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
if not head or not head.next:
return head
node = self.reverseList(head.next)
head.next.next = head #自己和邻居闭环
head.next = None #去向通路阻断
return node
25.合并两个排序的链表
#1.递归
class Solution:
def mergeTwoLists(self, l1, l2):
if l1 is None:
return l2
elif l2 is None:
return l1
elif l1.val < l2.val:
l1.next = self.mergeTwoLists(l1.next, l2)
return l1
else:
l2.next = self.mergeTwoLists(l1, l2.next)
return l2
#2.迭代
class Solution:
def mergeTwoLists(self, l1, l2):
dummy = ListNode(0)
pre = dummy
while l1 and l2:
if l1.val<=l2.val:
pre.next = l1
pre = pre.next
l1 = l1.next
else:
pre.next = l2
pre = pre.next
l2 = l2.next
if l1:
pre.next = l1
if l2:
pre.next = l2
return dummy.next