● 自己看到题目的第一想法
242. 有效的字母异位词
-
方法：
方法一： 暴力法1. 分别对s, t排序 2. 遍历s与t 判断s[i]!=t[i] 返回 false 否则 返回true -
思路：
-
注意：
-
代码：
bool cmp(char a, char b){
return a<b;
}
class Solution {
public:
bool isAnagram(string s, string t) {
int slen = s.size();
int tlen = t.size();
if(slen != tlen){
return false;
}
sort(t.begin(), t.end(),cmp);
sort(s.begin(), s.end(), cmp);
for(int i= 0; i<slen; i++){
cout<< s[i] <<endl ;
}
for(int j= 0; j<tlen; j++){
cout<< t[j] <<endl ;
}
for(int i= 0,j=0; i<slen,j<tlen; i++,j++){
if(s[i] != t[j]){
cout<< s[0] <<" "<<t[0]<<endl ;
cout<< s[1] <<" "<<t[1]<<endl ;
return false;
}
}return true;
}
};
-
运行结果：
-
方法二：哈希表
-
思路：
定义一个nums数组大小为26，初始值为0； 利用nums记分别录，s中字符出现的频次， t中字符出现的频次 若二者频次相同 则 return true 否则 return false; -
注意：
-
代码：
class Solution {
public:
bool isAnagram(string s, string t) {
int record[26]={0};
int slen = s.size();
int tlen = t.size();
for(int i = 0; i<slen; i++){
record[s[i] -'a']++;
}
for(int i =0; i<tlen; i++){
record[t[i]-'a']--;
}
for(int i=0; i<26; i++){
if(record[i] != 0){
return false;
}
}
return true;
}
};
class Solution {
public:
bool isAnagram(string s, string t) {
map<char, int>m;
for(int i =0; i<s.size(); i++){
m[s[i]]++;
}
for(int i=0; i<t.size(); i++){
m[t[i]]--;
}
for (auto it = m.begin(); it != m.end(); ++it) {
if (it->second != 0) {
return false;
}
}
//等价于
// for(auto it:map){
// if(it.second !=0){
// return false;
// }
// }
return true;
}
};
349. 两个数组的交集
-
方法：哈希表
-
思路：
该题的结果是去重的， 所以 确定使用 set 或 unordered_set 定义 集合 res 与 s set<int>s, res; 将nums1 放在 set中， set<int>s(nums1.begin(), nums2.end()); 在s中查找 nums2 是否出现在 s中， 出现则将nums2插入res中 s.find(nums2) !=s.end(); 返回 vector<int>(res.begin(), res.end()) -
注意：
-
代码：
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
set<int>s(nums1.begin(), nums1.end());
set<int>res;
for(auto nums: nums2){
if(s.find(nums) != s.end()){
res.insert(nums);
}
}
return vector<int>(res.begin(),res.end());
}
};
- 运行结果：
第202题. 快乐数
-
方法二：快慢指针
-
思路：
可能会出现的情况有两种， 1. 一个数最终会变成1 2. 一个数最终会陷入循环 3. 一个数最终会变得无限大（排除这种，不可能出现这种情况） 定义两个指针 fast (每次走两步) slow（每次走一步） 若fast 与slow 相遇 则 陷入循环 判断 fast==1 若是 则返回 true 否则返回false; 若不相遇 则 fast (每次走两步) slow（每次走一步） -
注意：
-
代码：
class Solution {
public:
int getsum(int n){
int sum =0;
while(n){
sum += (n%10)*(n%10);
n = n/10;
}
return sum;
}
bool isHappy(int n) {
int slow = n;
int fast = getsum(n);
while(slow != fast){
slow = getsum(slow);
fast = getsum(getsum(fast));
}
if(slow==1){
return true;
}
return false;
}
};
-
方法二：哈希表
-
思路：
可能会出现的情况有两种， 1. 一个数最终会变成1 2. 一个数最终会陷入循环 3. 一个数最终会变得无限大（排除这种，不可能出现这种情况） 定义哈希表unordered_set<int>set 若 set中出现sum 则返回false， 否则将sum加入到set中； 将n赋值到下一个计算的结果 n=sum -
注意： n要更新成下个计算的结果 即n=sum
-
代码：
class Solution {
public:
bool isHappy(int n) {
unordered_set<int>set;
while(1){
int x= getsum(n);
if(set.find(x) !=set.end()){
return false;
}else{
set.insert(x);
}
n=x;
if(x==1){
return true;
}
}
}
int getsum(int n){
int sum=0;
while(n){
sum += (n%10) * (n%10);
n=n/10;
}
return sum;
}
};
1. 两数之和
-
方法一：哈希表
-
思路：
定义一个unordered_map<int, int>map, 第一个是数 第二个是下标； 在map中查找 target-nums[i] 若存在 则返回 it->second 和下标 ，否则 将nums[i] 和 i 插入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++){
auto it = map.find(target-nums[i]);
if(it != map.end()){
return {it->second, i};
}
map.insert(pair<int, int>(nums[i], i));
}
return {};
}
};
-
方法二：暴力法
-
思路：
-
注意：
-
代码：
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
vector<int>res;
for(int i=0; i<nums.size(); i++){
for(int j=i+1; j<nums.size(); j++){
if(nums[i]+nums[j]==target){
// res.push_back(i);
// res.push_back(j);
res.insert(res.end(),{i,j});
return res;
}
}
}
return { };
}
};
