代码随想录5: 242. 有效的字母异位词、349. 两个数组的交集、1. 两数之和

weixin_51503393

已于 2024-04-09 22:55:55 修改

阅读量206

点赞数 3

文章标签：数据结构算法

于 2024-02-05 20:32:30 首次发布

本文链接：https://blog.csdn.net/weixin_51503393/article/details/136018638

版权

本文介绍了四种不同的编程解决方案：检查字符串是否为字母异位词（使用计数数组、哈希映射和排序），找出两个数组的交集，判断整数是否为快乐数（包括快慢指针和递归方法），以及寻找数组中两数之和（暴力双循环和哈希表）。

摘要由CSDN通过智能技术生成

242. 有效的字母异位词

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.size()!=t.size())
            return false;
        int a[256]={0},b[256]={0};
        int i=0,j=0;
        while(s[i]){
            a[s[i++]]++;
        }
        while(t[j]){
            b[t[j++]]++;
        }
        for(i=0;i<256;i++){
            if(a[i]!=b[i])
                return false;
        }
        return true;
    }
};

法二 map

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.size()!= t.size()) return false;
        unordered_map<char,int> map;
        int i=0;
        while(s[i]!='\0'){
            map[s[i]]++;
            map[t[i++]]--;
        }
        for(auto i : map){
            if(i.second != 0){
                return false;
            }
        }
        return true;
    }
};

法三排序

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.length() != t.length()) {
            return false;
        }
        sort(s.begin(), s.end());
        sort(t.begin(), t.end());
        return s == t;
    }
};

349. 两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set,nums_set(nums1.begin(),nums1.end());
        for(int num:nums2){
            if(nums_set.count(num))
            //if (nums_set.find(num) != nums_set.end())
                result_set.insert(num);
        }
        return vector<int>(result_set.begin(),result_set.end());
    }
};

202. 快乐数

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.count(sum))
            //if(set.find(sum)!=set.end())
                return false;
            else
                set.insert(sum);
            n=sum;
        }
    }
};

法二：快慢指针

	bool isHappy(int n) {
	    int slow=n,fast=getSum(n);
	    while(slow!=fast){
	        slow=getSum(slow);
	        fast=getSum(getSum(fast));
	    }
	    return fast==1;
	}

法三递归

class Solution {
public:
    set<int> set;
    bool isHappy(int n) {
        if(n==1){
            return true;
        }
        if(set.count(n)){
            return false;
        }else
            set.insert(n);
        string s = to_string(n);
        int sum=0;
        for(int i = 0; i < s.size(); ++i){
            sum+=(s[i]-'0')*(s[i]-'0');
        }
        return isHappy(sum);
    }
};

1. 两数之和

法一：暴力双循环

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res(2,0);
        for(int i=0;i<nums.size();i++){
            for(int j=i+1;j<nums.size();j++){
                if(nums[i]+nums[j]==target){
                    res[0]=i;
                    res[1]=j;
                }
            }
        }
        return res;
    }
};

法二：哈希unordered_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++){
            if(map.find(target-nums[i])!=map.end())
                return {map.find(target-nums[i])->second,i};
            else
                map.insert(pair<int, int>(nums[i], i));
        }
        return {};
    }
};