LeetCode242.有效的字母异位词
给定两个字符串 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 * 104
s
和t
仅包含小写字母
题目链接:242.有效的字母异位词
思路:运用哈希表,定义一个数组叫做record用来上记录字符串s里字符出现的次数。
遍历字符串s的时候,将 s[i] - ‘a’ 所在的元素做+1 操作,将字符串s中字符出现的次数统计出来
遍历字符串t的时候,对t中出现的字符映射哈希表索引上的数值再做-1的操作
最后检查record数组如果有的元素不为零0,说明字符串s和t一定是谁多了字符或者谁少了字符,return false。
class Solution {
public:
bool isAnagram(string s, string t) {
int record[26]={0};//一开始哈希表全部初始为0
for(int i=0;i<s.size();i++){
record[s[i]-'a']++;//将s数组里面的字符出现次数映射到哈希表的位置
}
for(int i=0;i<t.size();i++){
record[t[i]-'a']--;//将s数组里出现的字符次数映射到哈希表的位置并进行--
}
for(int i=0;i<26;i++){
if(record[i]!=0){//遍历26个位置,如果有不等于0的就说明s和t不是互为字母异位词
return false;
}
}
return true;
}
};
时间复杂度为O(n)
空间复杂度为O(1),空间上因为定义是的一个常量大小的辅助数组
LeetCode349. 两个数组的交集
给定两个数组 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
题目链接:349.两个数组的交集
思路:
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> result_set; // 存放结果,之所以用set是为了给结果集去重
unordered_set<int> nums_set(nums1.begin(), nums1.end());
for (int num : nums2) {
// 发现nums2的元素 在nums_set里又出现过
if (nums_set.find(num) != nums_set.end()) {
result_set.insert(num);
}
}
return vector<int>(result_set.begin(), result_set.end());
}
};
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int>result_set;
int hash[1005]={0};
for(int num:nums1){//将nums1出现的字母放入hash中
hash[num]=1;
}
for(int num:nums2){
if(hash[num]==1){//如果num2中出现的话,就把它放入num中
result_set.insert(num);
}
}
return vector<int>(result_set.begin(),result_set.end());
}
};
- 时间复杂度: O(n + m) m 是最后要把 set转成vector
- 空间复杂度: O(n)
LeetCode202. 快乐数
编写一个算法来判断一个数 n
是不是快乐数。
「快乐数」 定义为:
- 对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和。
- 然后重复这个过程直到这个数变为 1,也可能是 无限循环 但始终变不到 1。
- 如果这个过程 结果为 1,那么这个数就是快乐数。
如果 n
是 快乐数 就返回 true
;不是,则返回 false
。
示例 1:
输入:n = 19 输出:true 解释: 12 + 92 = 82 82 + 22 = 68 62 + 82 = 100 12 + 02 + 02 = 1
示例 2:
输入:n = 2 输出:false
提示:
1 <= n <= 231 - 1
题目链接:202.快乐数
思路:求和的过程中,sum会重复出现
判断sum是否重复出现,如果重复了就是return false, 否则一直找到sum为1为止。
判断sum是否重复出现就可以使用unordered_set。
class Solution {
public:
int getSum(int n) {
int sum=0;
while(n){
sum+=(n%10)*(n%10);
n/=10;
}
return sum;
}
bool isHappy(int n){
unordered_set<int>set;
while(1){
int sum=getSum(n);
if(sum==1){
return true;
}
if(set.find(sum)!=set.end()){
return false;
}else{
set.insert(sum);
}
n=sum;
}
}
};
- 时间复杂度: O(logn)
- 空间复杂度: O(logn)
LeetCode1. 两数之和
给定一个整数数组 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 <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
- 只会存在一个有效答案
题目链接:1.两数之和
思路:需要一个集合来存放我们遍历过的元素,然后在遍历数组的时候去询问这个集合,某元素是否遍历过,也就是 是否出现在这个集合。因为本题,我们不仅要知道元素有没有遍历过,还要知道这个元素对应的下标,需要使用 key value结构来存放,key来存元素,value来存下标,那么使用map正合适。
(以下摘自代码随想录)
再来看一下使用数组和set来做哈希法的局限。
- 数组的大小是受限制的,而且如果元素很少,而哈希值太大会造成内存空间的浪费。
- set是一个集合,里面放的元素只能是一个key,而两数之和这道题目,不仅要判断y是否存在而且还要记录y的下标位置,因为要返回x 和 y的下标。所以set 也不能用。
此时就要选择另一种数据结构:map ,map是一种key value的存储结构,可以用key保存数值,用value再保存数值所在的下标。
C++中map,有三种类型:
映射 | 底层实现 | 是否有序 | 数值是否可以重复 | 能否更改数值 | 查询效率 | 增删效率 |
---|---|---|---|---|---|---|
std::map | 红黑树 | key有序 | key不可重复 | key不可修改 | O(log n) | O(log n) |
std::multimap | 红黑树 | key有序 | key可重复 | key不可修改 | O(log n) | O(log n) |
std::unordered_map | 哈希表 | key无序 | key不可重复 | key不可修改 | O(1) | O(1) |
std::unordered_map 底层实现为哈希表,std::map 和std::multimap 的底层实现是红黑树。
判断元素是否出现,这个元素就要作为key,所以数组中的元素作为key,有key对应的就是value,value用来存下标。
所以 map中的存储结构为 {key:数据元素,value:数组元素对应的下标}。
在遍历数组的时候,只需要向map去查询是否有和目前遍历元素匹配的数值,如果有,就找到的匹配对,如果没有,就把目前遍历的元素放进map中,因为map存放的就是我们访问过的元素。
过程如下:
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
std::unordered_map<int,int>map;
for(int i=0;i<nums.size();i++){
auto iter=map.find(target-nums[i]);
if(iter!=map.end()){
return {iter->second,i};
}
map.insert(pair<int,int>(nums[i],i));
}
return {};
}
};
- 时间复杂度: O(n)
- 空间复杂度: O(n)
总结:还是觉得难,像unordered_map这些用的太少了,今天的博客写的大部分都是参考代码随想录了。
2024.7.23打卡 今日学习2.5hours