1.数组
easy
605. 种花问题
假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
给定一个花坛（表示为一个数组包含0和1，其中0表示没种植花，1表示种植了花），和一个数 n 。能否在不打破种植规则的情况下种入 n 朵花？能则返回True，不能则返回False。
示例 1:输入: flowerbed = [1,0,0,0,1], n = 1 输出: True
示例 2:输入: flowerbed = [1,0,0,0,1], n = 2 输出: False
思路：1，先添加边界，连续三个0就能插入1，但是为了避免00000五个零或者更多零的情况，插花之后把0，设置为1
技巧：1.想避免边界，再两边加0
列表想两边加0，直接s= [0] + s+[0]
def canPlaceFlowers(flowerbed, n):
flowerbed = [str(i) for i in flowerbed]
flowerbed = ''.join(flowerbed)
flowerbed = '0' + flowerbed + '0'
flowerbed = list(flowerbed)
a = 0
for i in range(1,len(flowerbed)-1):
if flowerbed[i] == '0' and flowerbed[i-1] == '0' and flowerbed[i+1] == '0':
a += 1
flowerbed[i] = '1'
if a >= n:
return True
else:
return False
17.10.主要元素
数组中占比超过一半的元素称之为主要元素。给定一个整数数组，找到它的主要元素。若没有，返回 - 1。
示例1：输入：[1, 2, 5, 9, 5, 9, 5, 5, 5] 输出：5
示例2：输入：[3, 2] 输出：-1
示例3：输入：[2, 2, 1, 1, 1, 2, 2] 输出：2
解题思路:
方法1 : 统计:先将nums去重，然后依次计算nums中每个元素的出现次数，如果大于一半则之间赋值并停止循环
方法2 ： 排序：将列表排序，然后循环，如果满足nums[i] == nums[i + halflen]，则赋值，并停止循环
class Solution:
def majorityElement(self, nums) -> int:
a = list(set(nums))
res = -1
for i in a:
if(nums.count(i) > len(nums) / 2):
res = i
break
return res;
class Solution:
def majorityElement(self, nums) -> int:
res = -1
halflen = int(len(nums) / 2)
nums.sort()
for i in range(0, len(nums) - halflen):
if (nums[i] == nums[i + halflen]):
res = nums[i]
break
return res
1. 两数之和
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
n = len(nums)
for i in range(n):
for j in range(i+1, n):
if nums[i]+nums[j] == target:
return [i,j]
return []
35. 搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 你可以假设数组中无重复元素。
示例 1: 输入: [1,3,5,6], 5 输出: 2
示例 2: 输入: [1,3,5,6], 2 输出: 1
示例 3: 输入: [1,3,5,6], 7 输出: 4
思路：
1.用二分法 注意：如果要插入的值特别大，要查在最后的话，直接判断一下；注意返回值 有的话； 用注意一定要注意，正常情况下都是while L <=， R 一定加上 等于，这样出来的就直接左边
2.直接把val附加到数组中，再进行排序，然后再index（）直接得到坐标
class Solution:
def searchInsert(self, nums: List[int], target: int) -> int:
ll = 0
rl = len(nums)-1
if target > nums[-1]:
return len(nums)
else:
while ll <= rl:
mid = (ll+rl) // 2
if nums[mid] > target:
rl = mid-1
elif nums[mid] < target:
ll = mid+1
else:
return mid
break
return ll
size = len(nums)
if size == 0:
return 0
if nums[size - 1] < target: # 特判
return size
left = 0
right = size - 1
while left < right:
mid = (left + right) // 2 # left + right 在 Python 中如果发生整型溢出，Python 会自动转成长整形
if nums[mid] < target: # 严格小于 target 的元素一定不是解
left = mid + 1 # 下一轮搜索区间是 [mid + 1, right]
else:
right = mid # 下一轮搜索区间是 [left, mid]
return left
nums.append(target)# 不管这个数在不在里面，直接append
nums.sort() # 然后再排序
return nums.index(target) # 最后返回查找的index
medim
2.字符串
easy
1576. 替换所有的问号
给你一个仅包含小写英文字母和’?‘字符的字符串s， 请你将所有的’?‘转换为若干小写字母， 使最终的字符串不包含任何连续重复的字符。
注意：你不能修改非’?‘字符。
题目测试用例保证除’?‘字符之外，不存在连续重复的字符。
在完成所有转换（可能无需转换）后返回最终的字符串。如果有多个解决方案，请返回其中任何一个。可以证明，在给定的约束条件下，答案总是存在的。
示例1：输入：s = “?zs” 输出：“azs”
解释：该示例共有25种解决方案，从"azs"到"yzs"都是符合题目要求的。只有"z"是无效的修改，因为字符串"zzs"中有连续重复的两个’z’ 。
示例2：输入：s = “ubv?w” 输出：“ubvaw”
解释：该示例共有24种解决方案，只有替换成"v"和"w"不符合题目要求。因为"ubvvw"和"ubvww"都包含连续重复的字符。
思路：1.两层循环+两个哨兵，解决边界问号，每趟判断当前位置的左右两侧是否满足条件，不满足，顺序查找字母替换即可
2.先首尾加上，方便处理，再遍历所有字符串
class Solution:
def modifyString(self, s: str) -> str:
s1= 'abcdefghijklmnopqrstuvwxyz'
res = list('0'+s+'0')
i=1
while i<len(res)-1:
if res[i]=='?':
j=0
while j<len(s1):
if s1[j] not in [res[i-1],res[i+1]]:
res[i]=s1[j]
break
j+=1
i+=1
return ''.join(res[1:-1])
import random
import string
def modifyString(s):
s = list('0' + s + '0')
for i in range(1, len(s)-1):
while s[i] == '?':
a = random.choice(string.ascii_lowercase)
if a != s[i-1] and a != s[i+1]:
s[i] = a
break
return ''.join(s[1:-1])
217.存在重复元素
给定一个整数数组，判断是否存在重复元素。
如果任意一值在数组中出现至少两次，函数返回true 。如果数组中每个元素都不相同，则返回false 。
示例1: 输入: [1, 2, 3, 1] 输出: true
示例2: 输入: [1, 2, 3, 4] 输出: false
示例3: 输入: [1, 1, 1, 3, 3, 4, 3, 2, 4, 2] 输出: true
思路：1.用哈希，把nums的元素作为key存入哈希中，如果value是1以上，即dict.get(i)即可判断，否接直接自加一
2.先把列表通过集合去重，对比长度变化
def containsDuplicate(nums) :
dict = {}
for i in nums:
#也可以这么写 if dict.get(i):
#dict.get(key, default=None)
if i in dict:
return True
else:
dict[i] = 1
return False
class Solution:
def containsDuplicate(self, nums: List[int]) -> bool:
n = len(nums)
num = list(set(nums))
m = len(num)
return n != m
389.找不同
给定两个字符串s和t，它们只包含小写字母。 字符串t由字符串s随机重排，然后在随机位置添加一个字母。 请找出在t中被添加的字母。
示例1： 输入：s = “abcd”, t = “abcde” 输出：“e”
示例2： 输入：s = “”, t = “y” 输出：“y”
示例3： 输入：s = “a”, t = “aa” 输出：“a”
思路：1.把s的存到字典中，t的存到字典中，比较key对应的val 不一样就返回
2.用循环，直接count（）个数相同是否
dict[i]和dict.get(i)的区别：
如果key都存在的话，两个返回的都是一样。
但是如果key不存在：dict[i]返回的报错
dict.get(i) 返回的是none；如果有其他用途的话可以再dict.get(i,default)设置默认值
dict = {}
dicty = {}
for i in t :
dict[i] = dict.get(i,0) +1
for j in s :
dicty[j] = dicty.get(j,0) +1
for n in t:
if dicty[n] != dict.get(n,0):
return n
class Solution:
def findTheDifference(self, s: str, t: str) -> str:
for i in t:
for i in s:
if s.count(i) != t.count(i):
return i
class Solution:
def findTheDifference(self, s: str, t: str) -> str:
for i in list(t):
if s.count(i) != t.count(i):
return i
medim
2.两数相加
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8
原因：342 + 465 = 807
思路一：直接暴力
考虑两种特殊情况：
1.长度不相等 123 + 45678
2.有进位的情形 11 + 99 = 110
最重要的一点就是：如何超过10下一位进位，用到s先取余加到p链表上，在求模当作下一次用
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
# 创建一个结点值为 None 的头结点, dummy 和 p 指向头结点, dummy 用来最后返回, p 用来遍历
dummy = p = ListNode(None)
s = 0 # 初始化进位 s 为 0
while l1 or l2 or s:
# 如果 l1 或 l2 存在, 则取l1的值 + l2的值 + s(s初始为0, 如果下面有进位1, 下次加上)
#这句话里的必须加上，因为如过99和9，到最后一l1和l2都没了，就不会输出1了，但是还要1，所以再加个判断s，s用完了就结束。
s += (l1.val if l1 else 0) + (l2.val if l2 else 0)
p.next = ListNode(s % 10) # p.next 指向新链表, 用来创建一个新的链表
p = p.next # p 向后遍历
s //= 10 # 有进位情况则取模, eg. s = 18, 18 // 10 = 1
l1 = l1.next if l1 else None # 如果l1存在, 则向后遍历, 否则为 None
l2 = l2.next if l2 else None # 如果l2存在, 则向后遍历, 否则为 None
return dummy.next # 返回 dummy 的下一个节点, 因为 dummy 指向的是空的头结点, 下一个节点才是新建链表的后序节点
思路二：递归
根据题意可知链表数字位数是从小到大的
因为两个数字相加会产生进位，所以使用i来保存进位。
则当前位的值为(l1.val + l2.val + i) % 10
则进位值为(l1.val + l2.val + i) / 10
建立新node，然后将进位传入下一层。
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
def dfs(l, r, i):
if not l and not r and not i: return None
s = (l.val if l else 0) + (r.val if r else 0) + i
node = ListNode(s % 10)
node.next = dfs(l.next if l else None, r.next if r else None, s // 10)
return node
return dfs(l1, l2, 0)
3.链表
easy
21.mergeTwoLists合并两个有序链表
将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4
思路一：创建新链表，比较大小链接上去
哑节点
创建 哑节点 作为 结果链表 的开头，返回结果是这个节点的下一个位置。目的是：在未遍历之前，我们不知道构建的结果中，开头元素到底是 l1 还是 l2, 为了让代码整齐，创建哑节点。
使用 move 游标
哑节点标记了 结果链表 的开头，因此是不能移动的。为了把两个链表 merge 的结果放到结果链表的最后，就需要使用一个 move 游标指向 结果链表 的最后一个元素。初始时，move 指向 哑节点，之后随着结果链表的增加而不停地向后移动，始终保持其指向 结果链表 的最后一个元素。
while 遍历两个元素
涉及到两个元素的遍历题，使用 while l1 and/or l2 的方式。即两个元素都没有遍历完或者至少有一个没遍历完，具体使用 and 还是 or 要根据场景进行选择。
这类常见的题目有：1.合并两个链表。 2.两数相加/两个链表表示的数相加
没用完的元素仍需拼接
当 while 循环结束之后，l1 和 l2 至少遍历完了一个，另一个链表可能没有用完，因此需要拼接到 结果链表 的结尾。
合并链表 或者 两数相加 都要记得这个问题。
至于本题并不难，只需要判断两个链表头部元素的大小，把小的那个链表节点放到 结果链表 的结尾即可。
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
dummy = ListNode()
move = dummy
while l1 and l2 :
if l1.val <= l2.val:
move.next = l1
l1 = l1.next
else:
move.next = l2
l2 = l2.next
move = move.next
move.next = l1 if l1 else l2
return dummy.next
思路二：递归
递归出口:俩链表都没有了那就return，所有结点都构建完成了
递归表达式，比较当前两个链表的结点，较小的那个作为新结点(返回值)，并顺着这个结点往下递归
# 算法模拟：
# 1,2,4 1,3,4
# 俩链表都非空,正常比较就可以
# 1 <= 1, 进入if
# l1 后面接 l1.next 和 l2 merge 的结果
# 这一轮比较的结果较小的是l1，所以将l1返回
# 递归里面[2,4]和[1,3,4]的比较
# 此时 l2 的头结点更小，进入 else
# l2后面接 l1 和 l2.next merge 的结果
# 这一轮比较的结果较小的是l2，所以返回是l2
# ... 如此递归下去
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
if not l1: return l2 # l1如果没有了，那就调用l2
if not l2: return l1 # l2如果没有了, 那就调用l2
if l1.val <= l2.val: # 将较小的结点 append 到当前的链表中
l1.next = self.mergeTwoLists(l1.next,l2) # l1走一步，l2不走
return l1 # 返回l1
else: # l2较小，结果链表中应该 append l2
l2.next = self.mergeTwoLists(l1,l2.next) # l2走一步, l1不走
return l2 # 返回l2。
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
if l1 and l2:
if l1.val > l2.val: l1, l2 = l2, l1
l1.next = self.mergeTwoLists(l1.next, l2)
return l1 or l2
思路三：把链表的值填入List合并后，用dummy填充新链表的方法
1.1首先把两个链表转换成两个list.
1.2再把这两个list合成一个newlist后，进行排序（sort）。
1.3最后设置dummy，逐个调取newlist的值以建立链表的每一个节点。
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
#1.1建立空表。
temp1, temp2 = [], []
#1.1设置与l1,l2相同的两个链表(optional)。
f1, f2 = l1, l2
#1.2用while循环把节点值填充至List。
while f1:
temp1.append(f1.val)
f1 = f1.next
while f2:
temp2.append(f2.val)
f2 = f2.next
#1.2合并两个List后进行排序。
temp = temp1 + temp2
temp.sort()
#1.3设置dummy，并且用List里面的值逐个填充新链表ff。
dummy = ff = ListNode(0)
for i in temp:
ff.next = ListNode(i)
ff = ff.next
return dummy.next
24. swapPairs两两交换链表中的节点
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换
输入：head = [1,2,3,4] 输出：[2,1,4,3]
输入：head = [] 输出：[]
输入：head = [1] 输出：[1]
思路一：暴力对比遍历交互
首先我们用考虑把大象装进冰箱分几步法考虑这个题。
我们要做的就是找到4个点：
当前：头（可以是空）-> 点1 -> 点2 -> 尾（可以是空）
目标：头（可以是空）-> 点2 -> 点1 -> 尾（可以是空）
我们需要干的活儿：
步1. 让头指向点2
步2. 让点2指向点1
步3. 让点1指向尾
然后就是，最开始其实是空的。所以先搞一个假头装上。
最后返回的时候再从假头后面开始返回链表就ok啦。
class Solution:
def swapPairs(self, head: ListNode) -> ListNode:
h = ListNode(0)
h.next = head # 假头
temph = h # 指针指向当前的头
while temph.next and temph.next.next: # 存在点1和点2
node1 = temph.next
node2 = temph.next.next
temph.next = node2 # 步1
node1.next = node2.next # 步2
node2.next = node1 # 步3
temph = node1 # 移动指针，指向新的头
return h.next
#自己写的报错，why
reason:1-2变成2-1；3-4变成4-3；但是1和4无法连
def swapPairs(self, head: ListNode) -> ListNode:
pre = head
tail = pre.next
while pre and tail :
pre.next = tail.next
tail.next = pre
pre = pre.next
tail = pre.next
return head.next
思路二：利用栈，迭代实现
利用stack
我们利用一个 stack，然后不断迭代链表，每次取出两个节点放入 stack 中，再从 stack 中拿出两个节点。
借助 stack 后进先出的特点，放进去的时候是 1,2 。拿出来的时候就是 2，1 两个节点了。再把这两个节点串联起来，重复这个逻辑遍历完整个链表，就可以做到两两反转的效果了。
虽然用到了 stack，但因为只存了两个元素，所以空间复杂度还是 O(1)O(1)O(1)，时间复杂度是 O(n)O(n)O(n)。
class Solution(object):
def swapPairs(self, head):
if not (head and head.next):
return head
p = ListNode(-1)
# 用stack保存每次迭代的两个节点
# head指向新的p节点，函数结束时返回head.next即可
cur,head,stack = head,p,[]
while cur and cur.next:
# 将两个节点放入stack中
_,_ = stack.append(cur),stack.append(cur.next)
# 当前节点往前走两步
cur = cur.next.next
# 从stack中弹出两个节点，然后用p节点指向新弹出的两个节点
p.next = stack.pop()
p.next.next = stack.pop()
p = p.next.next
# 注意边界条件，当链表长度是奇数时，cur就不为空
if cur:
p.next = cur
else:
p.next = None
return head.next
思路三：递归
用 head 表示原始链表的头节点，新的链表的第二个节点，用 newHead 表示新的链表的头节点，原始链表的第二个节点，则原始链表中的其余节点的头节点是 newHead.next。令 head.next = swapPairs(newHead.next)，表示将其余节点进行两两交换，交换后的新的头节点为 head 的下一个节点。然后令 newHead.next = head，即完成了所有节点的交换。最后返回新的链表的头节点 newHead。
class Solution:
def swapPairs(self, head: ListNode) -> ListNode:
if head == None or head.next == None:
return head
tail = head.next
head.next = self.swapPairs(tail.next)
tail.next = head
return tail
3.栈，堆
20. 有效的括号
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
示例 1: 输入: “()” 输出: true
示例 2: 输入: “()[]{}” 输出: true
示例 3:输入: “(]” 输出: false
示例 4:输入: “([)]” 输出: false
示例 5:输入: “{[]}” 输出: true
思路一：利用栈
因为是判断 括号，需要一对一对的，根据栈的先进后出原则，再创建一个字典：左括号一一对应右括号，如果左括号就进去栈，右括号就判断栈顶元素是否和字典对应的相等
注意：1.如果栈里面没东西了，还进入右括号，肯定是False，但是p.pop（）栈顶没元素会报错。
2.如果结束了栈内还有元素肯定也是错的
class Solution:
def isValid(self, s: str) -> bool:
dic = {')':'(',']':'[','}':'{'}
stack = []
for i in s:
if stack and i in dic:
if stack[-1] == dic[i]: stack.pop()
else: return False
else: stack.append(i)
return not stack
class Solution:
def isValid(self, s: str) -> bool:
p = []
dict = {'(':')','[':']','{':'}'}
for i in s:
if i in dict:
p.append(i)
else:
if not p or dict[p.pop()] != i:
return False
if not p:
return True
else:
return False
4. 滑动窗口
3. 无重复字符的最长子串
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1: 输入: “abcabcbb” 输出: 3 解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2: 输入: “bbbbb” 输出: 1 解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3: 输入: “pwwkew” 输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。 注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。
思路：创建个列表lookup存放不重复元素，遍历s，
如果i不在lookup中，直接把i附加上，并且长度加一，
如果在lookup中，找到索引index中，把索引的下一位作为lookup的起始，长度变了
注意：abcdd索引abcd的查下一个就为空了
但是记住：s =[1,2,3]
s =[4:]其实是[],并没有报错
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
if not s:return 0 # 如果字符串s为空，返回0
lookup = list() # 保存窗口内字符串
n = len(s)
max_len = 0 # 最大子串长度
cur_len = 0 # 当前窗口长度
for i in range(n): # 遍历字符串s
val = s[i]
if not val in lookup: # 如果该值不在窗口中
lookup.append(val) # 添加到窗口内
cur_len+=1 # 当前长度+1
else: # 如果该值在窗口中已存在
index = lookup.index(val) # 获取其在窗口中的位置
lookup = lookup[index+1:] # 移除该位置及之前的字符
lookup.append(val)
cur_len = len(lookup) # 当前长度更新为窗口长度
if cur_len > max_len:max_len = cur_len # 如果当前长度大于最大长度，更新最大长度值
return max_len # 返回最大子串长度
424.替换后的最长重复字符
给你一个仅由大写英文字母组成的字符串，你可以将任意位置上的字符替换成另外的字符，总共可最多替换 k 次。在执行上述操作后，找到包含重复字母的最长子串的长度。
注意:字符串长度 和 k 不会超过 104。
示例 1:输入:s = “ABAB”, k = 2 输出:4
解释:用两个’A’替换为两个’B’,反之亦然。
示例 2:输入:s = “AABABBA”, k = 1 输出:4
解释:将中间的一个’A’替换为’B’,字符串变为 “AABBBBA”。子串 “BBBB” 有最长重复字母, 答案为 4。
思路一：
思路二：
定义字典dict，right，left是字符串的双指针，用来控制窗口的滑动，这个窗口直接在s上遍历，max_freq是目前遍历s中出现次数最多的字符次数。
遍历过程中，字典里的dict[s[right]]加一。
当窗口长度-窗口中出现次数的字符次数<=k;就扩展窗口。因为例如abbc，k位2，遍历到当前状态，窗口长度=left-right+1=4，b或者a出现次数最多，为2，窗口长度-窗口中出现次数的字符次数<=k,替换两个可是变成太个是符合条件的。操作：右指针继续下一个
当窗口长度-窗口中出现次数的字符次数>k;就收缩窗口，操作：左指针加一，左指针在字典出现次数加一。
返回的是right-left，没有加一是因为right加一后不满足才跳出循环，所以不用写right-left+1
def characterReplacement(self, s: str, k: int) -> int:
dict = defaultdict(int)
right, left,max_freq= 0, 0, 0
while right < len(s):
dict[s[right]] += 1
max_freq = max(max_freq, dict[s[right]])
if (right - left + 1) - max_freq > k:
dict[s[left]] -= 1
left += 1
right += 1
return right - left
5.双指针
15. 三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]
思路一，三重循环，错误
第一种错误代码：三层循环，虽然可以实现大多数，但是1，0，-1，-1
会返回1，0，-1两次，可以这么解决：先排序，如果nums[i] == nums[i+1]；i+=1,j,t都一样可以解决或者跳出本次循环
上述错误：不可以解决，例如排完序后，-1，-1，0，1，2
这样-1，-1，2看不到，如果i这层循环不跳出来，就j，t这层相等跳出来，有可能会出现重复。这样解决不了。
def threeSum( nums):
n = len(nums)
for i in range(n):
for j in range(i+1, n):
for t in range(j+1, n):
if nums[i]+nums[j]+nums[t] == 0:
return [i, j, t]
思路二：双指针
若 nums[i]>0 ：因为已经排序好，所以后面不可能有三个数加和等于 0，直接返回结果。
对于重复元素：跳过，避免出现重复解
令左指针 L=i+1，右指针 R=n−1，当 L<R时，执行循环：
当 nums[i]+nums[L]+nums[R]==0n，执行循环，判断左界和右界是否和下一位置重复，去除重复解。并同时将 L,R 移到下一位置，寻找新的解
若和大于 0，说明 nums[R] 太大，R 左移
若和小于 0，说明 nums[L] 太小，L 右移
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
n = len(nums)
res = []
if (not nums or n < 3):
return []
nums.sort()
res = []
for i in range(n):
if (nums[i] > 0):
return res
if (i > 0 and nums[i] == nums[i - 1]):
continue
L = i + 1
R = n - 1
while (L < R):
if (nums[i] + nums[L] + nums[R] == 0):
res.append([nums[i], nums[L], nums[R]])
while (L < R and nums[L] == nums[L + 1]):
L = L + 1
while (L < R and nums[R] == nums[R - 1]):
R = R - 1
L = L + 1
R = R - 1
elif (nums[i] + nums[L] + nums[R] > 0):
R = R - 1
else:
L = L + 1
return res
344. 反转字符串
示例 1：输入：[“h”,“e”,“l”,“l”,“o”] 输出：[“o”,“l”,“l”,“e”,“h”]
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
思路：1.用库函数，或者reverse
2. 用双指针，s[i],s[j] = s[j],s[i]
s[:]=s[::-1]
class Solution:
def reverseString(self, s: List[str]) -> None:
j = len(s)-1
i = 0
while j-i >0:
s[i],s[j] = s[j],s[i]
j -= 1
i += 1
return s
27.移除元素
例子1：给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
思路一：1.遍历一遍数列，看是否有val，如果有一次就加一，最后返回，这样不严谨，因为并未按照要求改变数组。
2.对数组改变，引入两个指针i，j。i是慢指针，j是快指针，当有相同的元素是，j就加一，遇到不同的元素就把j的值给i，最后返回不一样的值都在i上
3.直接用内置函数count,计算有多少个count然后nums.remove(val)多少次
注意：虽然改变了数列[2,3,3,4,5,3] 和3 num[i]会先变成[2,4,5],但是后面的[4,5,3]会直接继承来的；实际上就是[2,4,5,4,5,3]
j = 0
for i in range(0,len(nums)):
if i == val:
j += 1
return len(nums)-j
双指针其实就是两个数，分别代表两个index，表示数组中第几个数的意思。
比如这里，我们让a代表一个index，b代表一个index
然后我们让a一直往后移动，相当于nums[a]从数组第一个数遍历到最后一个数。
当且仅当我们发现nums[a] != val的时候，我们把这个数拷贝到b指向的位置，默认b是从0开始的，然后b += 1指向下一个位置。
这样我们就保证了前b个数，就是我们要的结果。不重复的数。
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
a = 0
b = 0
while a < len(nums):
if nums[a] != val:
nums[b] = nums[a]
b += 1
a += 1
return b
class Solution:
def removeElement(self, nums: List[int], val: int) -> int:
n = len(nums)
m = nums.count(val)
for i in range(m):
nums.remove(val)
return n-m
125. 验证回文串
给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。说明：本题中，我们将空字符串定义为有效的回文串。
示例 1:输入: “A man, a plan, a canal: Panama” 输出: true
示例 2:输入: “race a car” 输出: false
思路：
1.先把字符串处理了，去除特殊符号，统一大小写，再双指针。
2.把数据处理后，用库函数直接翻转过来，然后和原来的比较
s = “”.join(ch.lower() for ch in s if ch.isalnum())直接取出特殊字符，并且都变成小写，isalnum函数是判断字符串是否由字母、数字组成
class Solution:
def isPalindrome(self, s: str) -> bool:
s = "".join(ch.lower() for ch in s if ch.isalnum())
l = 0
r = len(s) - 1
while l <= r:
if s[l] != s[r]:
return False
else:
l += 1
r -= 1
else:
return True
def isPalindrome(s):
s = "".join(ch.lower() for ch in s if ch.isalnum())
a = s[::-1]
return s == a
1.树
105. 从前序与中序遍历序列构造二叉树
根据一棵树的前序遍历与中序遍历构造二叉树。
注意:你可以假设树中没有重复的元素。
例如，给出 前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树
思路一：递归
preorder = [3,9,20,15,7] ; inorder = [9,3,15,20,7]
前序遍历第一个肯定是root节点，找到inorder的root节点的位置index
由于中序遍历是先左子树，root，右子树所以==index左边的是左子树，右边的是右子树。
无论是前序还是中序，左、右子树的节点肯定相同，所以分别的左右子树递归
root的左节点就是buildTree( preorder[1:index+1], inorder[:index] )
前序的root节点后开始到最后的节点数量，肯定和中序一样；
如果为空，递归结束返回None
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def buildTree(self, preorder, inorder) :
if not (preorder and inorder):
return None
root = TreeNode(preorder[0])
index = inorder.index(preorder[0])
root.left = self.buildTree( preorder[1:index+1], inorder[:index] )
root.right = self.buildTree(preorder[index+1:], inorder[index+1:] )
105. 从后序与中序遍历序列构造二叉树
根据一棵树的后序遍历与中序遍历构造二叉树。
注意:你可以假设树中没有重复的元素。
例如，给出 中序遍历 inorder = [9,3,15,20,7]
后序遍历 postorder = [9,15,7,20,3]
返回如下的二叉树
思路一：递归
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
def buildTree(self, inorder: List[int], postorder: List[int]) -> TreeNode:
if not (inorder and postorder):
return None
root = TreeNode(postorder[-1])
index = inorder.index(postorder[-1])
root.left = self.buildTree(inorder[:index], postorder[:index])
root.right = self.buildTree(inorder[index + 1:], postorder[index:-1])
return root
7.动态规划
70. 爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：输入： 2 输出： 2
解释： 有两种方法可以爬到楼顶。1. 1 阶 + 1 阶 2. 2 阶
示例 2：输入： 3 输出： 3
解释： 有三种方法可以爬到楼顶。1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶 3. 2 阶 + 1 阶
思路一：动态规划
根据数据dp；二是prev，cur，sum移动下一位
def climbStairs(self, n: int) -> int:
if n < 3: return n
res = [0 for i in range(n+1)]
res[1], res[2] = 1,2
for j in range(3,n+1):
res[j] = res[j-1] + res[j-2]
return res[n]
244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
