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]