242.有效的字母异位词
题目:给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1: 输入: s = "anagram", t = "nagaram" 输出: true
示例 2: 输入: s = "rat", t = "car" 输出: false
说明: 你可以假设字符串只包含小写字母。
哈希表法:以空间换时间
解题:此题实际上就是判断来个字符串是否由相同的字母组成,且字母的顺序不限制。
具体实现:由于小写字母的ascll码为连续的,因此只需要用一个大小为26的数组进行记录s与t中的字母的个数,进行相反的操作,最后数组中的元素应全为0。
bool isAnagram(char* s, char* t) {
int isflag[26]={0};
int l1=strlen(s),l2=strlen(t);
if(l1!=l2) return false;
for(int i=0;i<l1;++i){
isflag[s[i]-'a']++;
}
for(int i=0;i<l2;++i){
isflag[t[i]-'a']--;
}
for(int i=0;i<26;++i){
if(isflag[i]!=0){
return false;
}
}
return true;
}
349. 两个数组的交集
题目:题意:给定两个数组,编写一个函数来计算它们的交集。
示例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.用数组做哈希表
由于数字在0到1000之间,故可以用一个长1000(可以大一点)的数组进行统计,比较耗费空间,但是效率还是较高的。
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> ans;//能直接去重
unordered_set<int> myset(nums1.begin(), nums1.end());
for(int num:nums2){
if(myset.find(num)!=myset.end()){
ans.insert(num);
}
}
return vector<int>(ans.begin(),ans.end());
}
};
2.用unordered_set进行哈希映射
set和multiset底层实现都是红黑树,unordered_set的底层实现是哈希表, 因此,使用unordered_set 读写效率是最高的,并不需要对数据进行排序,而且还不要让数据重复,所以选择unordered_set。
int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
int isexist[1002]={0};
int* intersection=malloc(sizeof(int)*(nums1Size+nums2Size));
for(int i=0;i<nums1Size;++i){
isexist[nums1[i]]=1;
}
int k=0;
for(int i=0;i<nums2Size;++i){
if(isexist[nums2[i]]==1){
intersection[k++]=nums2[i];
isexist[nums2[i]]=0;//记录后要去重
}
}
*returnSize=k;
return intersection;
}
第202题. 快乐数
题目:编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为:对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和,然后重复这个过程直到这个数变为 1,也可能是 无限循环 但始终变不到 1。如果 可以变为 1,那么这个数就是快乐数。
如果 n 是快乐数就返回 True ;不是,则返回 False 。
1.哈希表检测是否发生循环
最简单的想法就是模拟,每次就算出每个位置上的数字的平方和,然后会由两种情况:
(1)该数是快乐数,因此当n==1时就会跳出循环,然后返回true
(2)该数不是快乐数,因此在while循环中必然会出现重复的数字,因此可以用哈希表来检测n的值是否发生了重复。
class Solution {
public:
int fun(int n){
int sum=0;
while(n){
int temp=n%10;
sum+=temp*temp;
n=n/10;
}
return sum;
}
bool isHappy(int n) {
int key=n;
unordered_set<int> myset;
while(n!=1){
n=fun(n);
if(myset.find(n)!=myset.end()) return false;//发生了循环
myset.insert(n);
}
return true;
}
};
2.快慢指针
由于此题涉及循环的判断,可以联系判断链表是否有环的那那一题。使用快慢指针来判断是否发生了循环。
class Solution {
public:
int fun(int n){
int sum=0;
while(n){
int temp=n%10;
sum+=temp*temp;
n=n/10;
}
return sum;
}
bool isHappy(int n) {
int slow=n;
int fast=fun(n);
while(fast!=1&&slow!=fast){
slow=fun(slow);//慢指针走一步
fast=fun(fun(fast));//快指针走两步
}
return fast==1;//最后判断是否为1
}
};
1. 两数之和
题目:给定一个整数数组 nums 和一个目标值 target,请你在该数组中找出和为目标值的那 两个 整数,并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
返回[0,1]
1.暴力解法
用两个for循环遍历即可。
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
int *ans=malloc(sizeof(int)*2);
*returnSize=2;
for(int i=0;i<numsSize;++i){
for(int j=i+1;j<numsSize;++j){
if(nums[i]+nums[j]==target){
ans[0]=i;
ans[1]=j;
}
}
}
return ans;
}
2.用map进行哈希映射
由于返回值是下标,因此需要通map进行存下标+值。要注意map的用法。
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map <int,int> map;
for(int i=0; i<nums.size();i++) {
// 遍历当前元素,并在map中寻找是否有匹配的key
auto iter=map.find(target-nums[i]);
if(iter!=map.end()) {
return {iter->second,i};
}
// 如果没找到匹配对,就把访问过的元素和下标加入到map中
map.insert(pair<int, int>(nums[i],i));
}
return {};
}
};