88
题目描述;
给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 的空间大小等于 m + n，这样它就有足够的空间保存来自 nums2 的元素。
示例：
解答：
class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
"""
Do not return anything, modify nums1 in-place instead.
"""
'''
nums1[m:]=nums2[:]
nums1.sort()
'''
i,j,k=m-1,n-1,m+n-1
while i>=0 and j>=0:
if nums1[i]<nums2[j]:
nums1[k]=nums2[j]
k-=1
j-=1
else:
nums1[k]=nums1[i]
k-=1
i-=1
if j>=0:
while j>=0:
nums1[k]=nums2[j]
k-=1
j-=1
1423
题目描述：
几张卡牌 排成一行，每张卡牌都有一个对应的点数。点数由整数数组 cardPoints 给出。
每次行动，你可以从行的开头或者末尾拿一张卡牌，最终你必须正好拿 k 张卡牌。
你的点数就是你拿到手中的所有卡牌的点数之和。
给你一个整数数组 cardPoints 和整数 k，请你返回可以获得的最大点数。
示例：
解答：
class Solution:
def maxScore(self, cardPoints: List[int], k: int) -> int:
#既然左右两边都可以取，那就直接看左边取n个，右边取k-n个
res = 0
total = [0]
flag = 0
for i in cardPoints: # 先记录累加和
flag += i
total.append(flag)
for i in range(0,k+1): # i是左边分配的位置
flag = total[i]+total[-1]-total[-1-k+i]
res = max(flag,res)
return res
剑指offer34
题目描述：
输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。
示例：
解答：
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
res, path = [], []
def recur(root, tar):
if not root: return
path.append(root.val)
tar -= root.val
if tar == 0 and not root.left and not root.right:
res.append(list(path))
recur(root.left, tar)
recur(root.right, tar)
path.pop()
recur(root, sum)
return res
剑指offer56-I
题目描述：
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是 O（n），空间复杂度是O（1）。
示例：
解答：
class Solution:
def singleNumbers(self, nums: List[int]) -> List[int]:
ret, index = 0, 0
for n in nums:
ret ^= n
# 找从右向左数第几位不同，也就是第index位
while ret & 1 == 0:
index += 1
ret >>= 1
r1, r2 = 0, 0
for n in nums:
if (n >> index) & 1 == 0:
r1 ^= n
else:
r2 ^= n
return [r1, r2]
剑指offer68-II
题目描述：
给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”
例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]
示例：
解答：
# 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 root == None:
return None
if root==p or root == q:
return root
left = self.lowestCommonAncestor(root.left,p,q) # 左右子树寻找p,q
right = self.lowestCommonAncestor(root.right,p,q)
if left and right: # 都找到了，一边一个
return root
if not left: # 左子树没有，即都在右子树
return right
if not right:
return left