LeetCode刷题 _「剑指 Offer]第2版_按顺序
参考链接：
剑指Offer（上）01-35题实现 python版本
剑指Offer（下）36-75题实现 Python版本
剑指 Offer 03. 数组中重复的数字
数组、哈希表、排序
class Solution:
def findRepeatNumber(self, nums: List[int]) -> int:
res = collections.Counter(nums)
for key in res:
if res[key] > 1:
return key
剑指 Offer 04. 二维数组中的查找
数组、二分查找、分治、矩阵
class Solution:
# 二分查找，使得每一次都可以分出两个相反的选择。
def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
if not matrix: # 考虑边界情况，特殊情况
return False
n, m = len(matrix), len(matrix[0]) # 从右上角开始，大的往下找，小的往左找
i, j = 0, m - 1
while 0 <= i < n and 0 <= j < m:
if matrix[i][j] == target:
return True
elif matrix[i][j] < target:
i += 1
else:
j -= 1
return False
剑指 Offer 05. 替换空格
字符串
class Solution:
def replaceSpace(self, s: str) -> str:
return s.replace(' ', "%20")
剑指 Offer 06. 从尾到头打印链表
栈、递归、链表、双指针
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def reversePrint(self, head: ListNode) -> List[int]:
res = []
while head:
res.append(head.val)
head = head.next
return res[::-1]
剑指 Offer 07. 重建二叉树
树、数组、哈希表、分治
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 分治思想，从前序遍历中找到根节点，从中序遍历中定位根节点计算出子树的长度
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
# 前序遍历：根左右， 中序遍历：左右根
self.preRootDict = {}
self.pre = preorder
for i in range(len(inorder)):
self.preRootDict[inorder[i]] = i # 记录中序结点的位置
return self.getRoot(0, 0, len(inorder) - 1) # 根节点，中序遍历范围
def getRoot(self, preRoot, inorderLeft, inorderRight):
if inorderLeft > inorderRight: # 中序遍历为空
return
root = TreeNode(self.pre[preRoot]) # 建立根结点
i = self.preRootDict[self.pre[preRoot]] # 找到前序遍历中根结点在中序中的位置
root.left = self.getRoot(preRoot + 1, inorderLeft, i - 1)
# preRoot当前的根 左子树的长度 = 左子树的右边-左边 (i-1-inorderLeft+1) 。最后+1就是右子树的根了
root.right = self.getRoot(preRoot + i - inorderLeft + 1, i + 1, inorderRight)
return root
剑指 Offer 09. 用两个栈实现队列
栈、设计、队列
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:
return self.stack2.pop()
else:
if self.stack1:
while self.stack1:
self.stack2.append(self.stack1.pop())
return self.stack2.pop()
return -1
剑指 Offer 10- I. 斐波那契数列
记忆化搜索、数学、动态规划
class Solution:
# # 效率不太高的递归
# def fib(self, n: int) -> int:
# if n <= 0:
# return 0
# if n == 1:
# return 1
# return self.fib(n - 1) + self.fib(n - 2)
# # 效率提升的动态规划
# def fib(self, n: int) -> int:
# if n <= 0:
# return 0
# if n == 1:
# return 1
# fibMinusOne = 0
# fibMinusTwo = 1
# fibN = 0
# for i in range(2, n + 1):
# fibN = fibMinusOne + fibMinusTwo
# fibMinusOne = fibMinusTwo
# fibMinusTwo = fibN
# return fibN % 1000000007
# 效率提升的动态规划
def fib(self, n: int) -> int:
if n <= 0:
return 0
if n == 1:
return 1
arr = [0, 1]
fibN = 0
for i in range(2, n + 1):
arr[i % 2] = arr[0] + arr[1]
return arr[i % 2] % 1000000007
剑指 Offer 10- II. 青蛙跳台阶问题
记忆化搜索、数学、动态规划
class Solution:
# 动态规划
def numWays(self, n: int) -> int:
if n == 1 or n == 0:
return 1
arr = [1, 1]
for i in range(2, n + 1):
arr[i % 2] = arr[0] + arr[1]
return arr[i % 2] % 1000000007
剑指 Offer 11. 旋转数组的最小数字
数组、二分查找
class Solution:
# 部分有序，二分查找。找出右排序数组中的第一个数字，也就是旋转点
# 时间复杂度：O(log2N), 空间复杂度：O(1)
def minArray(self, numbers: List[int]) -> int:
i, j = 0 , len(numbers) - 1
while i < j: # 已知j一定在右排序数组中
m = (i + j) // 2 # 当前的中心点
if numbers[m] > numbers[j]: i = m + 1 # 若右侧的点小于中心位置的点，m一定在左排序区间内，则说明旋转点一定在中心位置的右侧
elif numbers[m] < numbers[j]: j = m # 若右侧的点大于中心位置的点，m一定在右排序区间内，则说明旋转点一定在中心位置的左侧
else: j = j - 1 # 若相等，则需要进一步判断, 可参考某大佬评论
'''
若旋转点 x < j, 则上述肯定往左区间找
若旋转点 x = j, 则容易错过旋转点，但可以证明，nums[i]=nums[x]=nums[中心点]=...=nums[j]，则最终当i=j时返回的num[i]值等于旋转点的值
还有不用nums[m] 和 nums[i]做比较，因为无法判断 m 在哪个排序数组中
本质上，是因为 j 初始值肯定在右排序数组中； i 初始值无法确定在哪个排序数组中。
对于以下两示例，当 i = 0, j = 4, m = 2 时，有 nums[m] > nums[i] ，而结果不同。
[1, 2, 3, 4, 5] 旋转点 x = 0： m 在右排序数组（此示例只有右排序数组）；
[3, 4, 5, 1, 2] 旋转点 x = 3： m 在左排序数组。
'''
return numbers[i]
剑指 Offer 12. 矩阵中的路径
数组、回溯、矩阵
class Solution:
def exist(self, board: List[List[str]], word: str) -> bool:
def dfs(r, c, k):
if not 0 <= r < len(board) or not 0 <= c < len(board[0]) or board[r][c] != word[k]:
return False
if k == len(word) - 1:
return True
temp, board[r][c] = board[r][c], "/" # 用一个临时变量用于存储值，用于回溯
res = dfs(r - 1, c, k + 1) or dfs(r + 1, c, k + 1) or dfs(r, c - 1, k + 1) or dfs(r, c + 1, k + 1)
board[r][c] = temp
return res
for row in range(len(board)):
for col in range(len(board[0])):
if dfs(row, col, 0):
return True
return False
剑指 Offer 13. 机器人的运动范围
深度优先搜索、广度优先搜索
class Solution:
# # 广度优先遍历, BFS
# def movingCount(self, m: int, n: int, k: int) -> int:
# road = set() # 用一个集合存储所有的路径, 防止后面重复添加
# queue = []
# queue.append((0, 0))
# while queue:
# i, j = queue.pop()
# if (i, j) not in road and self.getSum(i, j) <= k:
# road.add((i, j))
# for di, dj in [[1, 0], [0, 1]]: # 仅考虑往右下方走就可以
# if 0 <= (i + di) < m and 0 <= (j + dj) < n:
# queue.append((i + di, j + dj))
# return len(road)
# def getSum(self, row, col): #计算当前方格的各个位上的和
# temp = 0
# while row > 0:
# temp += row % 10
# row = row // 10
# while col:
# temp += col % 10
# col = col // 10
# return temp
# 深度优先遍历, DFS
class Solution:
def movingCount(self, m: int, n: int, k: int) -> int:
def dfs(i, j):
if i >= m or j >= n or (i, j) in road or self.getSum(i, j) > k:
return
road.add((i, j)) # 加入路径中
dfs(i + 1, j) # 递归调用
dfs(i, j + 1) # 递归调用
road = set()
dfs(0, 0)
return len(road)
def getSum(self, row, col): #计算当前方格的各个位上的和
temp = 0
while row > 0:
temp += row % 10
row = row // 10
while col:
temp += col % 10
col = col // 10
return temp
剑指 Offer 14- I. 剪绳子
数学、动态规划
class Solution:
# 动态规划
def cuttingRope(self, n: int) -> int:
dp = [0 for _ in range(n + 1)]
dp[2] = 1 # 初始化
res = -1
for i in range(3, n + 1):
for j in range(1, i):
dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j])) # 三种情况, 1.不剪；2.从j处剪下来，剩下的i-j不再剪了；3.从j处剪下来，剩下的i-j继续剪
return dp[n]
剑指 Offer 14- II. 剪绳子 II
数学、动态规划
class Solution:
# 应尽可能的拆成多个3，当 n 小于等于 4 时，要特殊考虑
def cuttingRope(self, n: int) -> int:
if n < 4: return n - 1
a, b, p = n // 3, n % 3, 1000000007 # 把绳子尽可能切为多个长度为 3 的片段，留下的最后一段绳子的长度可能为 0,1,2 三种情况。
if b == 0: return 3 ** a % p # 0. 若最后一段绳子长度为 0
if b == 1: return 3 ** (a - 1) * 4 % p # 1. 若最后一段绳子长度为 2 ；则保留，不再拆为 1+1
return 3 ** a * 2 % p # 2. 若最后一段绳子长度为 1 ；则应把一份 3 + 1 替换为 2 + 2
剑指 Offer 15. 二进制中1的个数
位运算
class Solution:
# n & (n - 1)的运算会把最后一个1消去
def hammingWeight(self, n: int) -> int:
res = 0
while n != 0:
res += 1
n = n & (n - 1)
return res
剑指 Offer 16. 数值的整数次方
递归、数学
class Solution:
# 分治法
def myPow(self, x: float, n: int) -> float:
if n < 0: # 当 n < 0时，把问题转化至 n >= 0的范围内
x = 1 / x
n = -n
res = 1 # 初始化res = 1
while n:
if n & 1:
res *= x # 奇数位先乘以多出来的1
x *= x # 执行 x = x ^ 2
n >>= 1 # 执行n右移一位，缩小1半
return res
剑指 Offer 17. 打印从1到最大的n位数
数组、数学
class Solution:
# # 1.python自带的函数
# def printNumbers(self, n: int) -> List[int]:
# return list(range(1, 10**n))
# # 2.
# def printNumbers(self, n: int) -> List[int]:
# res = []
# for i in range(1, 10 ** n):
# res.append(i)
# return res
# 3.为正确表示大数
def printNumbers(self, n: int) -> List[int]:
def dfs(x):
if x == n: # 终止条件：已固定完所有位
s = ''.join(num[self.start:]) # 拼接 num
if s != '0': res.append(int(s)) # 不为 0 ，则添加至 res 尾部
if n - self.start == self.nine: self.start -= 1 # 如果此时除了 0 就是 9, 则下一次递归 0 的个数减少 1
return
for i in range(10): # 遍历 0 - 9
if i == 9: self.nine += 1 # 9 的个数加 1
num[x] = str(i) # 固定第 x 位为 i
dfs(x + 1) # 开启固定第 x + 1 位
self.nine -= 1
num, res = ['0'] * n, []
self.nine = 0 # 表示 9 的个数
self.start = n - 1 # 表示开始的 0 的个数
dfs(0)
return res
剑指 Offer 18. 删除链表的节点
链表
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def deleteNode(self, head: ListNode, val: int) -> ListNode:
if head.val == val: # 判断若头节点就是所找的数值
head = head.next
front = head
p = head.next
while p:
if p.val == val:
front.next = p.next
front = front.next
p = p.next
return head
剑指 Offer 19. 正则表达式匹配
递归、字符串、动态规划
class Solution:
# # 动态规划, 时间复杂度：O(mn), 空间复杂度：O(mn)
# def isMatch(self, s: str, p: str) -> bool:
# n, m = len(s), len(p)
# res = [[False] * (m + 1) for _ in range(n + 1)] # 状态转移的初始化
# for i in range(n + 1):
# for j in range(m + 1):
# if j == 0: # 第一种情况：空正则
# res[i][j] = (i == 0)
# else: # 第二种情况：非空正则
# if p[j - 1] != '*': # 非空正则情况之一: 非*
# if i > 0 and (s[i - 1] == p[j - 1] or p[j - 1] == '.'):
# res[i][j] = res[i - 1][j - 1]
# else: # 非空正则情况之一: *
# if j >= 2: # 不看a*的组合
# res[i][j] |= res[i][j - 2]
# if i >= 1 and j >= 2 and (s[i - 1] == p[j - 2] or p[j - 2] == '.'): # 看a*的组合
# res[i][j] |= res[i - 1][j] # 正则串不动, 主串前移一个
# return res[n][m]
# 递归, 时间复杂度：O(mn), 空间复杂度：O(mn)
def isMatch(self, s: str, p: str) -> bool:
# 如果字符串长度为0，需要检测下正则串
if len(s) == 0:
if len(p) % 2 != 0:
return False # 如果正则串长度为奇数，必定不匹配，比如 "."、"ab*",必须是 a*b*这种形式，*在奇数位上
i = 1
while i < len(p):
if p[i] != '*': return False
i += 2
return True
# 如果字符串长度不为0，但是正则串没了，return false
if len(p) == 0: return False
c1, c2, c3 = s[0], p[0], 'a' # c1 和 c2 分别是两个串的当前位，c3是正则串当前位的后一位，如果存在的话，就更新一下
if len(p) > 1:
c3 = p[1]
# 和dp一样，后一位分为是 '*' 和不是 '*' 两种情况
if c3 != '*': # 不是'*'
if c1 == c2 or c2 == '.':
return self.isMatch(s[1:], p[1:])
else: # 否则不匹配
return False
else: # 是'*'
if c1 == c2 or c2 == '.': # 如果该位字符一样，或是正则串该位是 '.'，和dp一样，有看和不看两种情况
return self.isMatch(s[1:], p) or self.isMatch(s, p[2:])
else:
return self.isMatch(s, p[2:]) # 不一样，那么正则串这两位就废了，直接往后走
剑指 Offer 20. 表示数值的字符串
字符串
class Solution:
# 状态转移，有限状态自动机
def isNumber(self, s: str) -> bool:
states = [
{' ': 0, 's': 1, 'd': 2, '.': 4}, # 0. start with blank
{'d': 2, '.': 4}, # 1.sign before e
{'d': 2, '.': 3, 'e': 5, ' ': 8}, # 2.digit before dot
{'d': 3, 'e': 5, ' ': 8}, # 3.digit after dot
{'d': 3}, # 4.digit after dot (is blank before dot)
{'s': 6, 'd': 7}, # 5.e
{'d': 7}, # 6.sign after e
{'d': 7, ' ': 8}, # 7.digit after e
{' ': 8}, # 8.end with blank
]
p = 0 # 以状态0开始
for c in s:
if '0' <= c <= '9': t = 'd' # digit
elif c in "+-": t = 's' # sign
elif c in "eE": t = 'e' # e or E
elif c in ". ": t = c # dot or blank
else: t = "?" # unkown
if t not in states[p]: return False
p = states[p][t]
return p in (2,3,7,8)
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
数组、双指针、排序
class Solution:
def exchange(self, nums: List[int]) -> List[int]:
pBegin, pEnd = 0, len(nums) - 1
while pBegin < pEnd:
# 当前pBegin指向奇数，向后移动pBegin
while pBegin < pEnd and (nums[pBegin] & 0x1) != 0:
pBegin += 1
# 当前pBegin指向偶数，向前移动pEnd
while pBegin < pEnd and (nums[pEnd] & 0x1) == 0:
pEnd -= 1
nums[pBegin], nums[pEnd] = nums[pEnd], nums[pBegin]
return num
剑指 Offer 22. 链表中倒数第k个节点
链表、双指针
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
if not head:
return None
front = second = head
for i in range(k): # 前面的指针先走k步
if not front: # 链表长度小于k，则返回None
return None
else:
front = front.next
while front: # 链表未到达末尾，所以前后指针分别前进
front = front.next
second = second.next
return second
剑指 Offer 24. 反转链表
递归、链表
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
# 用两个指针辅助，原链表逆转
# 时间复杂度：O(n), 空间复杂度：O(1)
def reverseList(self, head: ListNode) -> ListNode:
if not head: # 边缘情况
return None
pre = None
cur = head
while cur is not None:
next = cur.next
cur.next = pre
pre = cur
cur = next
return pre
剑指 Offer 25. 合并两个排序的链表
递归、链表
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
# 迭代实现
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
new_node = cur = ListNode(0)
while l1 and l2:
if l1.val < l2.val:
cur.next = l1
l1 = l1.next
else:
cur.next = l2
l2 = l2.next
cur = cur.next
cur.next = l1 if l1 else l2
return new_node.next
# # 递归实现
# def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
# if not l1:
# return l2
# elif not l2:
# return l1
# pMergedHead = ListNode(0)
# if l1.val < l2.val:
# pMergedHead.next = l1
# pMergedHead.next.next = self.mergeTwoLists(l1.next, l2)
# else:
# pMergedHead.next = l2
# pMergedHead.next.next = self.mergeTwoLists(l1, l2.next)
# return pMergedHead.next
剑指 Offer 26. 树的子结构
树、深度优先搜索、二叉树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 深度优先遍历，递归
def isSubStructure(self, A: TreeNode, B: TreeNode) -> bool:
if A == None or B == None:
return False
return self.dfs(A, B) or self.isSubStructure(A.left, B) or self.isSubStructure(A.right, B)
def dfs(self, A, B):
if B == None:
return True
if A == None:
return False
return A.val == B.val and self.dfs(A.left, B.left) and self.dfs(A.right, B.right)
剑指 Offer 27. 二叉树的镜像
树、深度优先搜索、广度优先搜索
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# # 递归实现
# def mirrorTree(self, root: TreeNode) -> TreeNode:
# if root == None:
# return None
# if root.left != None or root.right != None: # 交换左右子树
# root.left, root.right = root.right, root.left
# self.mirrorTree(root.left)
# self.mirrorTree(root.right)
# return root
# 迭代实现, 用栈实现
def mirrorTree(self, root: TreeNode) -> TreeNode:
stack = []
if not root:
return
stack.append(root)
while stack: # 将结点出栈，然后将该结点的左右子树入栈，交换左右子树。直到栈为空时结束。
cur_node = stack.pop()
if cur_node.left:
stack.append(cur_node.left)
if cur_node.right:
stack.append(cur_node.right)
cur_node.left, cur_node.right = cur_node.right, cur_node.left
return root
剑指 Offer 28. 对称的二叉树
树、深度优先搜索、广度优先搜索
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# # 递归
# def isSymmetric(self, root: TreeNode) -> bool:
# return self.help(root.left, root.right) if root else True
# def help(self, left, right):
# if not left and not right: # 如果左右两边都没有结点了，跳出条件之一
# return True
# if not left or not right or left.val != right.val: # #左没有结点或者右没有结点或者两个值不相等，跳出条件之二
# return False
# return self.help(left.left, right.right) and self.help(left.right, right.left)
# 迭代，利用树的层次遍历, 双端队列
def isSymmetric(self, root: TreeNode) -> bool:
if not root:
return True
queue = collections.deque()
queue.appendleft(root.left)
queue.append(root.right)
while queue:
left_node = queue.popleft()
right_node = queue.pop()
if not left_node and not right_node:
continue
if not left_node or not right_node or left_node.val != right_node.val:
return False
queue.appendleft(left_node.right)
queue.appendleft(left_node.left)
queue.append(right_node.left)
queue.append(right_node.right)
return True
剑指 Offer 29. 顺时针打印矩阵
数组、矩阵、模拟
class Solution:
# 矩阵的遍历
def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
if not matrix:
return matrix
top, bottom, left, right = 0, len(matrix) - 1, 0, len(matrix[0]) - 1
res = []
while True:
for i in range(left, right + 1): # 从左到右遍历
res.append(matrix[top][i])
top += 1 # 上边界向下收敛
if top > bottom: # 是否打印完毕
break
for j in range(top, bottom + 1): # 从上到下遍历
res.append(matrix[j][right])
right -= 1 # 右边界收敛
if right < left: # 是否打印完毕
break
for m in range(right, left - 1, -1): # 从右到左遍历
res.append(matrix[bottom][m])
bottom -= 1 # 下边界收敛
if top > bottom: # 是否打印完毕
break
for n in range(bottom, top - 1, -1): # 从下到上遍历
res.append(matrix[n][left])
left += 1 # 左边界收敛
if left > right: # 是否打印完毕
break
return res
剑指 Offer 30. 包含min函数的栈
栈、设计
class MinStack:
def __init__(self):
"""
initialize your data structure here.
"""
self.stackA = []
self.stackB = []
def push(self, x: int) -> None:
self.stackA.append(x)
if not self.stackB or self.stackA[-1] <= self.stackB[-1]:
self.stackB.append(x)
def pop(self) -> None:
if self.stackA.pop() == self.stackB[-1]:
self.stackB.pop()
def top(self) -> int:
return self.stackA[-1]
def min(self) -> int:
return self.stackB[-1]
剑指 Offer 31. 栈的压入、弹出序列
栈、数组、模拟
class Solution:
# 模拟栈弹出，压入
def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
stack = [] # 辅助栈
j = 0
for num in pushed:
stack.append(num) # 按照压入栈的顺序压元素进入辅助栈
while stack and stack[-1] == popped[j]: # 辅助栈不为空，并且栈顶元素等于弹出栈中元素，则弹出
stack.pop()
j += 1 # 弹出栈中元素后移
if not stack: # 最终如果辅助栈为空，说明可以按照新相应的压入顺序得到弹出栈顺序
return True
return False # 否则不可以
剑指 Offer 32 - I. 从上到下打印二叉树
树、广度优先搜索、二叉树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# # 二叉树的层次遍历，用队列
# def levelOrder(self, root: TreeNode) -> List[int]:
# if root is None:
# return []
# queue1, queue2, res = [], [], []
# queue1.append(root)
# while queue1:
# node = queue1.pop(0)
# res.append(node.val)
# if node.left:
# queue2.append(node.left)
# if node.right:
# queue2.append(node.right)
# if len(queue1) == 0:
# queue1 = queue2
# queue2 = []
# return res
# 二叉树的层次遍历，用队列
def levelOrder(self, root: TreeNode) -> List[int]:
if root is None:
return []
queue, res = [], []
queue.append(root)
while queue:
node = queue.pop(0)
res.append(node.val)
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return res
剑指 Offer 32 - II. 从上到下打印二叉树
树、广度优先搜索、二叉树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 层次遍历，队列
def levelOrder(self, root: TreeNode) -> List[List[int]]:
if root is None:
return []
queue1, queue2, res, temp = [], [], [], []
queue1.append(root)
while queue1:
node = queue1.pop(0)
temp.append(node.val)
if node.left:
queue2.append(node.left)
if node.right:
queue2.append(node.right)
if len(queue1) == 0:
res.append(temp)
temp = []
queue1 = queue2
queue2 = []
return res
剑指 Offer 32 - III. 从上到下打印二叉树
树、广度优先搜索、二叉树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def levelOrder(self, root: TreeNode) -> List[List[int]]:
if root is None:
return []
queue1, queue2, res, temp, count = [], [], [], [], 0
queue1.append(root)
while queue1:
node = queue1.pop(0)
temp.append(node.val)
if node.left:
queue2.append(node.left)
if node.right:
queue2.append(node.right)
if len(queue1) == 0:
if count % 2 == 0:
res.append(temp)
temp = []
else:
res.append(temp[::-1])
temp = []
count += 1
queue1 = queue2
queue2 = []
return res
剑指 Offer 33. 二叉搜索树的后序遍历序列
栈、树、二叉搜索树、递归
class Solution:
# 分治法，遍历左右根，运用递归精神
def verifyPostorder(self, postorder: List[int]) -> bool:
i = 0
j = len(postorder) - 1
return self.veriftyRes(postorder, i, j)
def veriftyRes(self, porder, i, j):
if i >= j:
return True
left = i
while porder[left] < porder[j]: # 左子树上的结点值应该小于根节点的值
left += 1
right = left # 划分左右子树，right位置为右子树起点
while porder[left] > porder[j]: # 右子树上的结点值应该大于根节点的值
left += 1
return left == j and self.veriftyRes(porder, i, right - 1) and self.veriftyRes(porder, right, j - 1)
剑指 Offer 34. 二叉树中和为某一值的路径
树、深度优先搜索、回溯、二叉树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
# 先序遍历
def pathSum(self, root: TreeNode, target: int) -> List[List[int]]:
res = [] # 最后的结果
path = [] # 遍历的路径
def preOrder(node, cur_Sum):
if not node: # 递归出口
return
path.append(node.val)
cur_Sum -= node.val # 算出之后遍历要得到的数字之和
if cur_Sum == 0 and not node.left and not node.right: # 保证此时数字之和就是所求，且是叶子节点
res.append(list(path)) # 此处因为list是可改变的格式, 需要复制保存
preOrder(node.left, cur_Sum) # 遍历左子树
preOrder(node.right, cur_Sum) # 遍历右子树
path.pop() # 恢复到上一层
preOrder(root, target)
return res
剑指 Offer 35. 复杂链表的复制
哈希表、链表
"""
# Definition for a Node.
class Node:
def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
self.val = int(x)
self.next = next
self.random = random
"""
class Solution:
# # 深拷贝，图的深度优先搜索
# def copyRandomList(self, head: 'Node') -> 'Node':
# visited = {} # 哈希表，字典
# return self.dfs(head, visited)
# def dfs(self, head, visited):
# if not head:
# return None
# if head in visited:
# return visited[head]
# copy = Node(head.val, None, None)
# visited[head] = copy
# copy.next = self.dfs(head.next, visited) # 先复制next结点
# copy.random = self.dfs(head.random, visited) # 再复制random结点
# return copy
# # 深拷贝，图的广度优先搜索
# def copyRandomList(self, head: 'Node') -> 'Node':
# visited = {} # 哈希表，字典
# return self.bfs(head, visited)
# def bfs(self, head, visited):
# if not head:
# return None
# copy = Node(head.val, None, None) # 创建新的结点
# queue = [] # 利用队列记录
# queue.append(head)
# visited[head] = copy
# while queue:
# node = queue.pop(0)
# if node.next and node.next not in visited:
# visited[node.next] = Node(node.next.val, None, None)
# queue.append(node.next)
# if node.random and node.random not in visited:
# visited[node.random] = Node(node.random.val, None, None)
# queue.append(node.random)
# visited[node].next = visited.get(node.next, None)
# visited[node].random = visited.get(node.random, None)
# return copy
# 迭代这种方法比较直接，就是分别拷贝next结点和random结点。
def copyRandomList(self, head: 'Node') -> 'Node':
visited = {} #构建一个链表来记录
def getCloneNode(node):
if node:
if node not in visited:
visited[node] = Node(node.val, None, None)
return visited[node]
else:
return visited[node]
if not head:
return head
old_node = head
new_node = Node(old_node.val, None, None)
visited[old_node] = new_node
while old_node:
new_node.next = getCloneNode(old_node.next)
new_node.random = getCloneNode(old_node.random)
old_node = old_node.next
new_node = new_node.next
return visited[head]
剑指 Offer 36. 二叉搜索树与双向链表
栈、树、深度优先搜索
"""
# Definition for a Node.
class Node:
def __init__(self, val, left=None, right=None):
self.val = val
self.left = left
self.right = right
"""
class Solution:
# 对二叉搜索树进行排序，相当于中序遍历二叉树，然后放入链表
def treeToDoublyList(self, root: 'Node') -> 'Node':
def dfs(cur):
if not cur: # 递归出口
return
dfs(cur.left) # 中序遍历，左右根
if self.pre: # pre不为None, 说明找到了头结点
self.pre.right = cur
cur.left = self.pre
else:
self.head = cur # 此时找到头结点
self.pre = cur
dfs(cur.right)
if not root: # 特殊输入的处理
return None
self.pre = None # 保存前一结点，最终是尾结点
dfs(root)
self.head.left = self.pre # 头结点的左孩子是尾结点
self.pre.right = self.head # 尾结点的右孩子是头结点
return self.head
剑指 Offer 37. 序列化二叉树
树、深度优先搜索、广度优先搜索
# Definition for a binary tree node.
# class TreeNode(object):
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
import collections
class Codec:
# # 树的层次遍历, 广度优先遍历
# def serialize(self, root):
# if not root:
# return "[]"
# queue = collections.deque()
# queue.append(root)
# res = []
# while queue:
# node = queue.popleft()
# if node:
# res.append(str(node.val))
# queue.append(node.left)
# queue.append(node.right)
# else:
# res.append("null")
# return '[' + ','.join(res) + ']'
# def deserialize(self, data):
# if data == "[]":
# return
# vals, i = data[1: -1].split(','), 1
# root = TreeNode(int(vals[0]))
# queue = collections.deque()
# queue.append(root)
# while queue:
# node = queue.popleft()
# if vals[i] != 'null':
# node.left = TreeNode(int(vals[i]))
# queue.append(node.left)
# i += 1
# if vals[i] != 'null':
# node.right = TreeNode(int(vals[i]))
# queue.append(node.right)
# i += 1
# return root
# 前序遍历，深度优先搜索
def serialize(self, root):
return self.rserialize(root, "")
def rserialize(self, root, strs):
if root == None:
strs += "None,"
else:
strs += str(root.val) + ","
strs = self.rserialize(root.left, strs)
strs = self.rserialize(root.right, strs)
return strs
def deserialize(self, data):
dataArray = data.split(",")
dataList = list(dataArray)
return self.rdeseralize(dataList)
def rdeseralize(self, dataList):
if dataList[0] == "None":
dataList.pop(0)
return None
root = TreeNode(int(dataList[0]))
dataList.pop(0)
root.left = self.rdeseralize(dataList)
root.right = self.rdeseralize(dataList)
return root
剑指 Offer 38. 字符串的排列
字符串、回溯
class Solution:
# # 方法一：递归 + 回溯
# def permutation(self, s: str) -> List[str]:
# strs, n, res = list(s), len(s), []
# def backtrace(num):
# if num == n: # 跳出条件
# res.append("".join(strs))
# return
# jihe = set()
# for i in range(num, n):
# if strs[i] in jihe:
# continue
# jihe.add(strs[i])
# strs[i], strs[num] = strs[num], strs[i] # 固定num的位置
# backtrace(num + 1) # 开始固定num + 1的位置
# strs[i], strs[num] = strs[num], strs[i] # 恢复
# backtrace(0)
# return res
# 方法二：利用回溯模板
def permutation(self, s: str) -> List[str]:
if not s:
return
strs, res = list(sorted(s)), []
def backtrace(strs, tmp):
if not strs:
res.append(''.join(tmp))
for i in range(len(strs)):
if i > 0 and strs[i] == strs[i - 1]: # 去重
continue
backtrace(strs[:i] + strs[i + 1:], tmp + [strs[i]])
backtrace(strs, [])
return res
剑指 Offer 39. 数组中出现次数超过一半的数字
数组、哈希表、分治、计数、排序
class Solution:
# # 摩尔投票法
# def majorityElement(self, nums: List[int]) -> int:
# if not nums: # 边界情况
# return 0
# target = nums[0]
# res = 1 # 控制一个计数量res
# for i in range(1, len(nums)):
# if nums[i] == target: # 如果跟前一个数相同，就加1
# res += 1
# else: # 如果跟前一个数不相同，则减1
# res -= 1
# if res == 0:
# target = nums[i] # res为0时，重新赋值
# res = 1
# return target # 最后剩下的数就是超过一半的数
# 字典哈希
def majorityElement(self, nums: List[int]) -> int:
if not nums: # 边界情况
return 0
target = len(nums) // 2
numDict = {}
for num in nums:
if num in numDict:
numDict[num] += 1
else:
numDict[num] = 1
if numDict[num] > target:
return num
剑指 Offer 40. 最小的k个数
数组、分治、快速选择、排序
import heapq
class Solution:
# # 排序方法：大根堆， 不改变数组中数的位置
# # 时间复杂度：O(logK), 空间复杂度：O(k)
# def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
# if k == 0: # 处理边界情况
# return list()
# hp = [-x for x in arr[:k]] # 因为python语言中的堆为小根堆，所以需要对数组中所有的值取反，才能使用小根堆维护前k个数
# heapq.heapify(hp) # 将列表list转换为heap堆,在现行时间内，重新排列表
# for i in range(k, len(arr)): # 从第k+1个数开始遍历
# if -hp[0] > arr[i]: # 如果当前遍历到的数比大根堆的堆顶的数要小
# heapq.heappop(hp) # 弹出堆顶的数
# heapq.heappush(hp, -arr[i]) # 往堆中插入当前遍历到的数
# res = [-x for x in hp] # 最后将大根堆的数存入数组返回
# return res
# 排序方法：快速排序, 改变数组中数的位置
# 时间复杂度：O(logK), 空间复杂度：O(k)
def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
length = len(arr)
if k <= 0 or k > length: # 边界情况
return list()
left, right = 0, length - 1 # 左右指针
while left < right:
res = self.partition(arr, left, right) # 确定left的数在arr中位置
if res == k - 1: # 如果刚好是k - 1的位置，说明此时找到前k个数字
break
elif res < k - 1: # 如果位置偏左，则调整左指针
left = res + 1
else:
right = res - 1 # 如果位置偏右，则调整右指针
return arr[: k]
def partition(self, arr, left, right):
cur_res = arr[left]
while left < right:
while left < right and arr[right] >= cur_res:
right -= 1
arr[left] = arr[right]
while left < right and arr[left] <= cur_res:
left += 1
arr[right] = arr[left]
arr[left] = cur_res
return left
剑指 Offer 41. 数据流中的中位数
设计、双指针、数据流、排序
from heapq import *
class MedianFinder:
# # 自带函数sort()的排序, 时间复杂度：O(nlogn)
# def __init__(self):
# """
# initialize your data structure here.
# """
# self.store = []
# def addNum(self, num: int) -> None:
# self.store.append(num)
# def findMedian(self) -> float:
# self.store.sort()
# n = len(self.store)
# if n & 1:
# return self.store[n // 2]
# else:
# return (self.store[n // 2 - 1] + self.store[n // 2]) / 2
# 堆排序, 时间复杂度：O(n)
def __init__(self):
"""
initialize your data structure here.
"""
self.left = [] # 大顶堆，保存左半部分小于中位数的数据
self.right = [] # 小顶堆，保存右半部分大于中位数的数据
def addNum(self, num: int) -> None:
if len(self.left) == len(self.right): # 当左右两顶堆长度相同时，插入左边的大顶堆
heapq.heappush(self.right, num) # 此时数据大于右边小顶堆的最小值，需要插入右边的小顶堆
heapq.heappush(self.left, -heapq.heappop(self.right)) # 并把右边小顶堆的最小值插入左边大顶堆
else: # 当左右两顶堆长度不相同时，肯定是左边大顶堆数目多于右边小顶堆的数目，插入右边的小顶堆
heapq.heappush(self.left, -num) # 此时数据小于左边大顶堆的最大值，需要插入大边的大顶堆
heapq.heappush(self.right, -heapq.heappop(self.left)) # 并把左边大顶堆的最大值插入右边小顶堆
def findMedian(self) -> float:
if len(self.left) == 0:
return 0
if len(self.left) == len(self.right):
mid = (self.right[0] - self.left[0]) / 2.0
else:
mid = -self.left[0]
return mid
剑指 Offer 42. 连续子数组的最大和
数组、分治、动态规划
class Solution:
# 动态规划，维护以当前数字为结尾的子数组的和
def maxSubArray(self, nums: List[int]) -> int:
if not nums: # 边界情况
return 0
nCurSum = 0
nGreatestSum = nums[0]
for num in nums:
if nCurSum <= 0: # num之前的最大子数组的和 比0小就更新为 num --- f(i) = num 当i=0或者f(i - 1) <= 0
nCurSum = num
else: # num之前的最大子数组的和 比0大就更新为 加上num --- f(i) = f(i-1) + num 当i!=0或者f(i - 1) > 0
nCurSum += num
if nCurSum > nGreatestSum:
nGreatestSum = nCurSum
return nGreatestSum
剑指 Offer 43. 1～n 整数中 1 出现的次数
递归、数学、动态规划
class Solution:
# 数学
def countDigitOne(self, n: int) -> int:
k, mulk = 0, 1 # mulk 表示 10 ** k
res = 0
while n >= mulk:
res += (n // (mulk * 10)) * mulk + min(max(n % (mulk * 10) - mulk + 1, 0), mulk) # 计算结果
k += 1
mulk *= 10
return res
剑指 Offer 44. 数字序列中某一位的数字
数学、二分查找
class Solution:
# 数学
def findNthDigit(self, n: int) -> int:
digit, start, count = 1, 1, 9 # 分别初始化 位数, 起始, 数位
while n > count: # 1. 确定 n 所在数字的位数 digit
n -= count
digit += 1 # 1, 2, 3, ...
start *= 10 # 1, 10, 100, ...
count = 9 * digit * start # 9, 180, 2700, ...
num = start + (n - 1) // digit # 2. 确定所求数位所在的数字 num
return int(str(num)[(n - 1) % digit]) # 3. 确定所求数位在num中的哪一位
剑指 Offer 45. 把数组排成最小的数
贪心、字符串、排序
class Solution:
# 类似于快速排序的的思想
# 时间复杂度：O(nlogn), 最差为O(n^2). 空间复杂度：O(n)
def minNumber(self, nums: List[int]) -> str:
strs = [str(num) for num in nums]
def quickSort(left, right):
if left >= right: # 递归出口
return
i, j = left, right
while i < j:
# 字符串的比较是比较ASCII码值。
# 从字符串的第一个字符开始比较，谁的ASCII码大谁就大。如果第一个相同，则比较第二个。以此类推。如果都相同则相等。
while i < j and strs[j] + strs[left] >= strs[left] + strs[j]: # 保证位置j右边的数都应该在left位置右边
j -= 1
while i < j and strs[i] + strs[left] <= strs[left] + strs[i]: # 保证位置i左边的数都应该在left位置左边
i += 1
strs[i], strs[j] = strs[j], strs[i] # 调整此时的i，j位置的数，放在应该放在的位置
strs[i], strs[left] = strs[left], strs[i] # 把left放在应该排序的位置
quickSort(left, i - 1) # 递归排序left左边的数, 直到递归出口
quickSort(i + 1, right) # 递归排序right右边的数, 直到递归出口
quickSort(0, len(nums) - 1) # 递归开始
return "".join(strs)
剑指 Offer 46. 把数字翻译成字符串
字符串、动态规划
class Solution:
# 动态规划，时间复杂度: O(n) ,空间复杂度：O(1)
# def translateNum(self, num: int) -> int:
# str_num = str(num)
# dp_i_1, dp_i_2 = 1, 1 # 当字符长度是0和1，都分别只有一种翻译方法
# for i in range(2, len(str_num) + 1):
# if "10" <= str_num[i - 2: i] <= "25": # 这个期间的数字可以拆成两种
# dp_i = dp_i_1 + dp_i_2 # dp[i] = dp[i - 1] + dp[i - 2]
# else: # dp[i] = dp[i - 1]
# dp_i = dp_i_1
# dp_i_2 = dp_i_1 # 像车轮一样翻滚，更新它们
# dp_i_1 = dp_i
# return dp_i_1
# 动态规划，时间复杂度: O(n) ,空间复杂度：O(n)
# def translateNum(self, num: int) -> int:
# str_num = str(num)
# dp = [1] * (len(str_num) + 1)
# for i in range(2, len(str_num) + 1):
# if "10" <= str_num[i - 2: i] <= "25": # 这个期间的数字可以拆成两种
# dp[i] = dp[i - 1] + dp[i - 2]
# else:
# dp[i] = dp[i - 1]
# return dp[len(str_num)]
# 动态规划，时间复杂度: O(n) ,空间复杂度：O(1) 优化上述的空间效率
def translateNum(self, num: int) -> int:
str_num = str(num)
dp = [1] * 2
for i in range(2, len(str_num) + 1):
if "10" <= str_num[i - 2: i] <= "25": # 这个期间的数字可以拆成两种
dp[i % 2] = dp[(i - 1) % 2] + dp[(i - 2) % 2]
else:
dp[i % 2] = dp[(i - 1) % 2]
return dp[len(str_num) % 2]
剑指 Offer 47. 礼物的最大价值
数组、动态规划、矩阵路径
class Solution:
# # 动态规划，时间复杂度O(mn), 空间复杂度O(mn)
# def maxValue(self, grid: List[List[int]]) -> int:
# m, n = len(grid), len(grid[0])
# res = [[0] * n for _ in range(m)]
# res[0][0] = grid[0][0]
# for i in range(1, m):
# res[i][0] = res[i - 1][0] + grid[i][0]
# for j in range(1, n):
# res[0][j] = res[0][j - 1] + grid[0][j]
# for i in range(1, m):
# for j in range(1, n):
# res[i][j] = max(res[i - 1][j], res[i][j - 1]) + grid[i][j]
# return res[m - 1][n - 1]
# # 动态规划，时间复杂度O(mn), 空间复杂度O(n) 两行
# def maxValue(self, grid: List[List[int]]) -> int:
# m, n = len(grid), len(grid[0])
# res = [[0] * n for _ in range(2)]
# res[0][0] = grid[0][0]
# for j in range(1, n):
# res[0][j] = res[0][j - 1] + grid[0][j]
# for i in range(1, m):
# res[i % 2][0] = res[(i - 1) % 2][0] + grid[i][0]
# for j in range(1, n):
# res[i % 2][j] = max(res[(i - 1) % 2][j], res[i % 2][j - 1]) + grid[i][j]
# return res[(m - 1) % 2][n - 1]
# 动态规划，时间复杂度O(mn), 空间复杂度O(n) 一行
def maxValue(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
res = [0] * n
res[0] = grid[0][0]
for j in range(1, n):
res[j] = res[j - 1] + grid[0][j]
for i in range(1, m):
res[0] = res[0] + grid[i][0]
for j in range(1, n):
res[j] = max(res[j], res[j - 1]) + grid[i][j]
return res[n - 1]
剑指 Offer 48. 最长不含重复字符的子字符串
哈希表、字符串、滑动窗口
class Solution:
# # 蛮力法
# def lengthOfLongestSubstring(self, s: str) -> int:
# if not s:
# return 0
# longest = 0
# for start in range(len(s)):
# for end in range(start, len(s)):
# count = end - start + 1
# substring = s[start: end + 1]
# position = dict()
# if not self.hasDuplication(substring, position):
# if count > longest:
# longest = count
# else:
# break
# return longest
# def hasDuplication(self, substring, position):
# for i in range(len(substring)):
# indexInposition = ord(substring[i]) - ord('a')
# if indexInposition in position:
# return True
# position[indexInposition] = indexInposition
# return False
# 动态规划
def lengthOfLongestSubstring(self, s: str) -> int:
if not s: # 边界情况
return 0
temp = dict() # 保存与当前字符一样的下标
dp = [0] * len(s) # 用来记录以j为结尾的最长不重复子字符串
for j in range(len(s)):
i = temp.get(s[j], -1) #获取与当前字符s[j]一样的字符的下标
temp[s[j]] = j # 更新字典
if dp[j - 1] < j - i : # 状态转移方程 i < 0 或者 dp[j - 1] < j - i
dp[j] = dp[j - 1] + 1
else:
dp[j] = j - i
return max(dp)
剑指 Offer 49. 丑数
哈希表、数学、动态规划
class Solution:
# 动态规划
def nthUglyNumber(self, n: int) -> int:
dp, a, b, c = [1] * n, 0, 0, 0
for i in range(1, n):
n2, n3, n5 = dp[a] * 2, dp[b] * 3, dp[c] * 5
dp[i] = min(n2, n3, n5)
if dp[i] == n2: a += 1
if dp[i] == n3: b += 1 # 必须要是if，如果既等于n2，又等于n3，则都跳过
if dp[i] == n5: c += 1
return dp[-1]
剑指 Offer 50. 第一个只出现一次的字符
队列、哈希表、字符串、计数
class Solution:
# 利用哈希特征来进行高效查找
def firstUniqChar(self, s: str) -> str:
if not s:
return " "
haxi = dict()
for num in s:
if num in haxi: haxi[num] += 1
else: haxi[num] = 1
for num in haxi:
if haxi[num] == 1:
return num
return " "
剑指 Offer 51. 数组中的逆序对
树状数组、线段树、数组
class Solution:
# 归并排序, 左右指针, 时间复杂度：O(n), 空间复杂度：O(n)
def mergeSort(self, nums, tmp, l, r):
if l >= r:
return 0
mid = (l + r) // 2
inv_count = self.mergeSort(nums, tmp, l, mid) + self.mergeSort(nums, tmp, mid + 1, r)
i, j, pos = l, mid + 1, l
while i <= mid and j <= r:
if nums[i] <= nums[j]:
tmp[pos] = nums[i]
i += 1
inv_count += (j - (mid + 1)) # 逆序对个数
else:
tmp[pos] = nums[j]
j += 1
pos += 1
for k in range(i, mid + 1): # 左指针没有到达 mid, 则接下来比较
tmp[pos] = nums[k]
inv_count += (j - (mid + 1))
pos += 1
for k in range(j, r + 1): # 右指针没有达到 r, 则接下来比较
tmp[pos] = nums[k]
pos += 1
nums[l: r + 1] = tmp[l: r + 1] # 更新下一次归并的数组
return inv_count
def reversePairs(self, nums: List[int]) -> int:
n = len(nums)
tmp = [0] * n # 辅助数组
return self.mergeSort(nums, tmp, 0, n - 1)
剑指 Offer 52. 两个链表的第一个公共节点
哈希表、链表、双指针
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
# 时间复杂度：O(m+n)， 空间复杂度：O(1)
def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
nLength1 = self.GetListLength(headA) # 得到两个链表的长度
nLength2 = self.GetListLength(headB)
nLengthDif = nLength1 - nLength2
pListHeadLong = headA
pListHeadShort = headB
if nLength2 > nLength1:
pListHeadLong = headB
pListHeadShort = headA
nLengthDif = nLength2 - nLength1
for i in range(nLengthDif): # 先在长链表上走几步，再同时在两个链表上遍历
pListHeadLong = pListHeadLong.next
while pListHeadLong != None and pListHeadShort != None and pListHeadShort != pListHeadLong:
pListHeadLong = pListHeadLong.next
pListHeadShort = pListHeadShort.next
return pListHeadLong # 得到第一个公共结点
def GetListLength(self, pHead):
nLength = 0
pNode = pHead
while pNode != None:
nLength += 1
pNode = pNode.next
return nLength
剑指 Offer 53 - I. 在排序数组中查找数字 I
数组、二分查找
class Solution:
# # 二分查找，找是target的值的位置
# def search(self, nums: List[int], target: int) -> int:
# left, right = 0, len(nums) - 1
# res = 0
# while left <= right:
# m = (left + right) // 2
# if nums[m] == target: # 若找到目标值后，从中心扩散，寻找上下界
# res += 1
# i = m - 1
# j = m + 1
# while j <= len(nums) - 1 and nums[j] == target:
# res += 1
# j += 1
# while i >= 0 and nums[i] == target:
# res += 1
# i -= 1
# break
# elif nums[m] < target:
# left = m + 1
# else:
# right = m - 1
# return res
# 二分查找，相当于找左右边界，找不是target的值的位置
def search(self, nums: List[int], target: int) -> int:
i, j = 0, len(nums) - 1
while i <= j:
m = (i + j) // 2
if nums[m] <= target: # i想找的是第一个大于target的数
i = m + 1
else:
j = m - 1
right = i # 找右边界
i, j = 0, len(nums) - 1
while i <= j:
m = (i + j) // 2
if nums[m] < target:
i = m + 1 # 尝试查找比target小的更大的数
else: # j想找的是第一个小于target的数
j = m - 1 # 尝试查找大于等于target的更小的数
left = j # 找左边界
return right - left - 1
剑指 Offer 53 - II. 0～n-1中缺失的数字
位运算、数组、哈希表、数学
class Solution:
# 二分查找
def missingNumber(self, nums: List[int]) -> int:
i, j = 0, len(nums) - 1
while i <= j:
mid = (i + j) // 2
if nums[mid] == mid:
i = mid + 1
else:
j = mid - 1
return i
剑指 Offer 54. 二叉搜索树的第k大节点
树、深度优先搜索、二叉搜索树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 二叉搜索树的中序遍历是从小到大排序，如果中序遍先右后左，每次k值减小1，当k值减小到0时, root.val即为所求
def kthLargest(self, root: TreeNode, k: int) -> int:
self.k = k
def dfs(node):
if not node:
return
dfs(node.right) # 遍历右子树
self.k -= 1 # 减一
if self.k == 0: # 保存结果
self.res = node.val
return
dfs(node.left) # 遍历左子树
dfs(root)
return self.res
剑指 Offer 55 - I. 二叉树的深度
树、深度优先搜索、广度优先搜索
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# # 后序遍历，循环
# def maxDepth(self, root: TreeNode) -> int:
# if not root:
# return 0
# return max(self.maxDepth(root.left), self.maxDepth(root.right)) + 1
# 层次遍历，循环
def maxDepth(self, root: TreeNode) -> int:
if not root:
return 0
queue, res = [root], 0
while queue:
tmp = []
for node in queue:
if node.left: tmp.append(node.left)
if node.right: tmp.append(node.right)
queue = tmp
res += 1
return res
剑指 Offer 55 - II. 平衡二叉树
树、深度优先搜索、二叉树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# # 递归，从顶开始，判断深度
# def isBalanced(self, root: TreeNode) -> bool:
# if not root:
# return True
# return abs(self.depth(root.left) - self.depth(roo t.right)) <= 1 and self.isBalanced(root.left) and self.isBalanced(root.right)
# def depth(self, root):
# if not root:
# return 0
# return max(self.depth(root.left), self.depth(root.right)) + 1
# 迭代，后序遍历 + 剪枝
def isBalanced(self, root: TreeNode) -> bool:
def lastSort(root):
if not root:
return 0
left = lastSort(root.left) # 判断左子树是否满足平衡二叉树， 满足的话返回左子树的深度
if left == -1: # 左子树，不满足，返回-1
return -1
right = lastSort(root.right) # 判断右子树是否满足平衡二叉树， 满足的话返回右子树的深度
if right == -1: # 右子树，不满足，返回-1
return -1
if abs(left - right) <= 1: # 当前左右子树的父节点是否满足平衡二叉树，满足的话返回其父节点的深度
return max(left, right) + 1
else:
return -1
return lastSort(root) != -1
剑指 Offer 56 - I. 数组中数字出现的次数
位运算、数组
class Solution:
def singleNumbers(self, nums: List[int]) -> List[int]:
res = 0 # 保留异或结果
a, b = 0, 0 # 分组异或
for num in nums:
res ^= num # 所有数字异或, 最终表示的是两个不同的数字的结果
position = 1 # 开始找第一位不是0的数，也就是第一位两个数开始不同的位置
while res & position == 0:
position <<= 1
for num in nums: # 开始分组
if position & num == 0: # a记录的是第一位不为0的数
a ^= num
else:
b ^= num
return [a, b]
剑指 Offer 56 - II. 数组中数字出现的次数 II
位运算、数组
class Solution:
# 应用位操作，若某一位上1出现的次数不是3的倍数，则唯一出现的数字该位上为1
def singleNumber(self, nums: List[int]) -> int:
res = 0
for i in range(32):
cnt = 0 # 记录该位置上1的个数
bit = 1 << i # 记录当前要操作的bit
for num in nums:
if num & bit != 0:
cnt += 1 # 记录该位置上1出现的次数0
if cnt % 3 != 0:
res |= bit # 保留该位上的结果
return res
剑指 Offer 57. 和为s的两个数字
数组、双指针、二分查找
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
left, right = 0, len(nums) - 1
while left < right: # 二分查找
if nums[left] + nums[right] > target:
right -= 1
elif nums[left] + nums[right] < target:
left += 1
else:
return [nums[left], nums[right]]
return []
剑指 Offer 57 - II. 和为s的连续正数序列
数学、双指针、枚举
class Solution:
# 滑动窗口解题, 双指针
def findContinuousSequence(self, target: int) -> List[List[int]]:
left, right = 1, 2
res = []
while right <= target // 2 + 1: # 最大也是target的二分之一
cur_num = []
s = (left + right) * (right - left + 1) // 2 # 求窗口中连续数的和
if s < target: # 如果小于目标值，右指针增长
right += 1
elif s > target: # 如果大于目标值，左指针增长
left += 1
else: # 如果为目标值，保存结果
for num in range(left, right + 1):
cur_num.append(num)
res.append(cur_num)
right += 1
return res
剑指 Offer 58 - I. 翻转单词顺序
双指针、字符串
class Solution:
def reverseWords(self, s: str) -> str:
s = s.strip() # 删除首位空格
left = right = len(s) - 1 # 两个指针的初始位置
res = []
while left >= 0: # 从尾部开始往前移动
while left >= 0 and s[left] != ' ': # 搜索直到遇到空格
left -= 1
res.append(s[left + 1: right + 1]) # 把之前的单词加入到结果中
while s[left] == " ": # 当指针遇到空格，跳过
left -= 1
right = left # right指向下一个单词尾部
return " ".join(res)
剑指 Offer 58 - II. 左旋转字符串
数学、双指针、字符串
class Solution:
# 字符串切片
def reverseLeftWords(self, s: str, n: int) -> str:
s1 = s[:n]
s2 = s[n:]
return s2 + s1
# # 旋转操作
# def reverseLeftWords(self, s: str, n: int) -> str:
# s = list(s) # 因为字符串是不可变序列，还有元组
# length = len(s) - 1
# self.reverse(s, 0, n - 1)
# self.reverse(s, n, length)
# self.reverse(s, 0, length)
# return "".join(s)
# def reverse(self, s, start, end):
# while start < end:
# s[start], s[end] = s[end], s[start]
# start += 1
# end -= 1
剑指 Offer 59 - I. 滑动窗口的最大值
队列、滑动窗口、单调队列
import collections
import heapq
class Solution:
# # 优先队列，时间复杂度: O(nlogn)， 空间复杂度: O(n)
# def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
# if not nums:
# return []
# n = len(nums)
# q = [[-nums[i], i] for i in range(k)] # 注意python默认的优先队列是最小堆
# heapq.heapify(q)
# res = [-q[0][0]] # 记录当前最大值
# for i in range(k, n):
# heapq.heappush(q, [-nums[i], i])
# while q[0][1] <= i - k: # 堆中的值不在当前窗口中
# heapq.heappop(q)
# res.append(-q[0][0])
# return res
# 双端队列，时间复杂度: O(n), 空间复杂度: O(k)
def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
if not nums or k == 0: # 边界情况
return []
deque = collections.deque() # 构建队列记录当前最大值的序列
for i in range(k): # 在未形成窗口前
while deque and deque[-1] < nums[i]: # 队列为空或者队列尾部元素小于数组中的当前元素
deque.pop() # 此时队尾元素不可能是当前窗口的最大值，弹出
deque.append(nums[i])
res = [deque[0]] # 将第一个窗口中的最大值写入结果栈中
for i in range(k, len(nums)): # 已经形成窗口了
if deque[0] == nums[i - k]: # 队列头部元素
deque.popleft() # 弹出队首元素，维护当前元素是在窗口中
while deque and deque[-1] < nums[i]: # 维护双端队列是单调递减的，不断将新的元素与队尾元素相比较
deque.pop() # 弹出队尾元素
deque.append(nums[i])
res.append(deque[0])
return res
剑指 Offer 59 - II. 队列的最大值
设计、队列、单调队列
class MaxQueue:
# 双队列
def __init__(self):
self.queue = []
self.max_queue = []
def max_value(self) -> int:
if not self.queue:
return -1
return self.max_queue[0]
def push_back(self, value: int) -> None:
self.queue.append(value)
while self.max_queue and value > self.max_queue[-1]:
self.max_queue.pop(-1)
self.max_queue.append(value)
def pop_front(self) -> int:
if not self.queue:
return -1
if self.queue[0] == self.max_queue[0]:
self.max_queue.pop(0)
return self.queue.pop(0)
剑指 Offer 60. n个骰子的点数
数学、动态规划、概率与统计
class Solution:
# 动态规划，时间复杂度：O(n^2), 空间复杂度：O(n)
def dicesProbability(self, n: int) -> List[float]:
dp = [1/6] * 6 # 初始化
for i in range(2, n + 1):
tmp = [0] * (5 * i + 1) # 本轮点数之和共有情况: 6*i - (i - 1) = 5i + 1 种
for j in range(len(dp)):
for k in range(6):
tmp[j + k] += dp[j] / 6
dp = tmp
return dp
剑指 Offer 61. 扑克牌中的顺子
数组、排序
class Solution:
# # 方法一，不排序，如这五张牌连续，需要满足条件1:这五张牌没有重复，条件2:最大值-最小值<5。
# def isStraight(self, nums: List[int]) -> bool:
# repeat = set()
# max_num, min_num = 0, 14 # 最大值初始化为最小值，最小值初始化为最大值
# for num in nums:
# if num == 0: continue
# max_num = max(max_num, num) # 最大值
# min_num = min(min_num, num) # 最小值
# if num in repeat: # 保证repeat中没有重复的数
# return False
# repeat.add(num) # 集合中添加num
# return max_num - min_num < 5
# 方法二，先排序，判断有没有重复的，判断和最小值之间是不是相差值小于5，和前一种方法不同的点在于，判断重复时直接和上一个位置值判断是不是一样就OK
def isStraight(self, nums: List[int]) -> bool:
nums.sort()
joker = 0 # 计算大小王数量
for i in range(len(nums) - 1):
if nums[i] == 0: # 记录大小王数量
joker += 1
elif nums[i] == nums[i + 1]: # 如果有重复，则直接判断不成立
return False
return nums[4] - nums[joker] < 5 # 第joker数位代表的除0之外最小的数
剑指 Offer 62. 圆圈中最后剩下的数字
递归、数学
class Solution:
# # 计算机模拟，暴力超时了
# def lastRemaining(self, n: int, m: int) -> int:
# lists = list(range(n))
# i = 0
# while len(lists) > 1:
# i = (i + m - 1) % len(lists) # 计算出当前要删除第一个元素
# lists.pop(i) # 然后从lists中弹出第几个元素
# return lists[0]
# 数学方法，约瑟夫环问题
def lastRemaining(self, n: int, m: int) -> int:
num = 0
for i in range(2, n + 1):
num = (num + m) % i
return num
剑指 Offer 63. 股票的最大利润
数学、动态规划
class Solution:
# 动态规划，记录以当前数字结尾的子数组的最大利润
def maxProfit(self, prices: List[int]) -> int:
if not prices: # 边界情况
return 0
profit = 0
min_price = prices[0]
for price in prices:
min_price = min(min_price, price)
profit = max(price - min_price, profit)
return profit
剑指 Offer 64. 求1+2+…+n
位运算、递归、脑筋急转弯
class Solution:
def __init__(self):
self.res = 0
# 位运算。逻辑运算符
def sumNums(self, n: int) -> int:
n > 1 and self.sumNums(n - 1)
self.res += n
return self.res
剑指 Offer 65. 不用加减乘除做加法
位运算、数学
class Solution:
def add(self, a: int, b: int) -> int:
x = 0xffffffff # 与该数相与，可以舍去数字32位以上的数字
a, b = a & x, b & x # 将a, b从无限长度变成一个32位整数
while b != 0:
a, b = (a ^ b), (a & b) << 1 & x # 异或结果得到非进位和; 相与得到进位和，左移1位是作为下一位，并且需要与x与截获前32位
# python中没有int，long等不同长度变量，既没有变量位数的概念
# 获取负数的补码：与十六进制0xffffffff 相与，舍去此数字32位以上的数字，从无限长度变为一个32位整数
# 返回前数字还原：若补码a为负数(最大的整数补码是0x7fffffff)，需执行~(a ^ x)， 将1至32位按位取反，再整个数字取反
return a if a <= 0x7fffffff else ~(a ^ x) # 如果是正数，就直接返回
剑指 Offer 66. 构建乘积数组
数组、前缀和
class Solution:
# 计算上三角和下三角
def constructArr(self, a: List[int]) -> List[int]:
b = [1] * len(a)
tmp = 1
for i in range(1, len(a)):
b[i] = b[i - 1] * a[i - 1] # 从上到下计算下三角
for i in range(len(a) - 2, - 1, -1):
tmp *= a[i + 1] # 从下到上计算上三角
b[i] *= tmp
return b
剑指 Offer 67. 把字符串转换成整数
字符串
class Solution:
def strToInt(self, strs: str) -> int:
res, i, sign, length = 0, 0, 1, len(strs)
int_max, int_min, bndry = 2 ** 31 - 1, - 2 ** 31, 2 ** 31 // 10
if not strs: return 0 # 空字符串，返回0
while strs[i] == " ":
i += 1
if i== length: return 0 # 字符串全为空格，提前返回
if strs[i] == "-": sign = -1
if strs[i] in "+-": i += 1
for c in strs[i:]:
if not '0' <= c <= '9': break
if res > bndry or res == bndry and c > '7':
return int_max if sign == 1 else int_min
res = 10 * res + ord(c) - ord('0')
return sign * res
剑指 Offer 68 - I. 二叉搜索树的最近公共祖先
树、深度优先搜索、二叉搜索树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 利用二叉搜索树的特点, 利用值来判断
def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
if p.val > q.val:
p, q = q, p # 保障 p.val < q.val， 减少比较次数
while root:
if root.val < p.val:
root = root.right # 两个值均在右子树中
if root.val > q.val:
root = root.left # 两个值均在左子树中
else:
break
return root
剑指 Offer 68 - II. 二叉树的最近公共祖先
树、深度优先搜索、二叉树
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
# 后序遍历，递归
def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
if not root or root == p or root == q: # 递归出口，1，越过叶节点 2.当root等于p，q
return root
left = self.lowestCommonAncestor(root.left, p, q) # 递归工作，递归左子节点
right = self.lowestCommonAncestor(root.right, p, q) # 递归工作，递归右子节点
if not left: # left 为空，right 不为空
return right
if not right: # right 为空，left 不为空
return left
return root # left, right都不为空