Leetcode 242.字母异位词,19.两个数组的交集,142.两数之和
Leetcode 242
题目
给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的字母异位词。
注意:若 s 和 t 中每个字符出现的次数都相同,则称 s 和 t 互为字母异位词。
示例 1:
输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:
输入: s = “rat”, t = “car”
输出: false
提示:
1 <= s.length, t.length <= 5 *
1
0
4
10^4
104
2. s 和 t 仅包含小写字母
算法思想:
该类问题用哈希表解决。首先定义一个包含26个字母的哈希表;其次遍历其中一个数组,将对应字母的内容修改为出现的次数;最后遍历另外一个数组,将对应位置的出现次数减1,直到遍历完整个数组。
代码实现:
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
# 通常容易想到用两个数组解决问题,但是这道目可以做加法然后做减法的操作。
record = [0] * 26
for i in s:
record[ord(i) - ord('a')] += 1
for j in t:
record[ord(j) - ord('a')] -= 1
for k in range(len(record)):
if record[k] != 0:
return False
return True
复杂度:
时间复杂度:
O
(
n
)
O(n)
O(n)
空间复杂度:
O
(
1
)
O(1)
O(1)
Leetcode 349
题目
给定两个数组 nums1 和 nums2 ,返回它们的交集 。输出结果中的每个元素一定是唯一 的。我们可以不考虑输出结果的顺序 。
示例 1:
输入:nums1 = [1,2,2,1], nums2 = [2,2]
输出:[2]
示例 2:
输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出:[9,4]
解释:[4,9] 也是可通过的
提示:
- 1 <= nums1.length, nums2.length <= 1000
- 0 <= nums1[i], nums2[i] <= 1000
算法思想:
该类问题用哈希表解决。首先定义一个数组 / 字典记录原始数据,如果使用数组:定义一个1001或以上的数组,用于存这个范围内的所有的数字。其次定义一个set()用来保存最终的交集。
代码实现:
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
# # 第一种方法:使用一行哈希表存储所有元素
# table = {}
# for i in nums1:
# table[i] = table.get(i, 0) + 1
# # 使用set保存结果,自动去重
# res = set()
# for i in nums2:
# if i in table:
# res.add(i)
# return list(res)
# 第二种方法:使用数组解决问题
table = [0] * 1001
for i in nums1:
table[i] = 1
# 使用set保存结果,自动去重
res = set()
for i in nums2:
if table[i] == 1:
res.add(i)
return list(res)
Leetcode 1
题目
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例1:
输入: nums = [2,7,11,15], target = 9
输出: [0,1]
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
示例2:
输入: nums = [3,2,4], target = 6
输出: [1,2]
示例3:
输入: nums = [3,3], target = 6
输出: [0,1]
提示:
- 2 <= nums.length <= 1 0 4 10^4 104
- - 1 0 9 10^9 109 <= nums[i] <= 1 0 9 10^9 109
- - 1 0 9 10^9 109<= target <= 1 0 9 10^9 109
- 仅存在一个有效答案
示例 1:
输入:nums1 = [1,2,2,1], nums2 = [2,2]
输出:[2]
示例 2:
输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出:[9,4]
解释:[4,9] 也是可通过的
提示:
5. 1 <= nums1.length, nums2.length <= 1000
6. 0 <= nums1[i], nums2[i] <= 1000
算法思想:
该类问题用哈希表解决。首先定义一个dict,用来存储那些元素被访问过,其中key是元素,value是序号。或使用双指针法,首先要将列表排序,如果不排序,一旦left + right != target, 就不清楚左右指针走向的问题。
代码实现:
# 第一种解法:使用map/dict
# # 通常:哈希法的map 对应python中是个dict
# records = dict() # 保存的是已经被遍历过的元素,key是元素,value是索引;如果反过来村存储,对于查找当前元素是否被遍历过不是很友好
# for index, ele in enumerate(nums):
# if target - ele in records:
# return [records[target-ele], index]
# else:
# records[ele] = index
# return []
# 第二种解法:使用双指针
sorted_nums = sorted(nums)
left = 0
right = len(nums) - 1
while left < right:
sum_lr = sorted_nums[left] + sorted_nums[right]
if sum_lr == target:
left_o = nums.index(sorted_nums[left])
right_o = nums.index(sorted_nums[right])
if left_o == right_o:
right_o = nums[left_o+1:].index(sorted_nums[right]) + left_o + 1
return [left_o, right_o]
return [left_o, right_o]
elif sum_lr > target:
right = right - 1
else:
left = left + 1
复杂度:
时间复杂度:
O
(
n
)
O(n)
O(n)
空间复杂度:
O
(
n
)
O(n)
O(n)