代码随想录算法训练营第六天| LeetCode242 有效的字母异位词、LeetCode349 两个数组的交集、LeetCode202 快乐数、LeetCode1 两数之和-CSDN博客

本文链接：https://blog.csdn.net/jinyang1110/article/details/135922437

242.有效的字母异位词

思路：利用哈希表，由于小写字母只有26位，定义一个26位的数组，首先判断字符串1中各个字母的数量，然后判断字符串2与数组中字母数量是否相同，如果相同就是字母异位词，如果不相同则不是。

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

349. 两个数组的交集

思路：利用set容器构造哈希表，先将数组1，放入哈希表，之后遍历数组2，查找哈希表中是否有和数组2中的元素相同的元素，如果有，储存到新的数组里，遍历结束后，返回新的数组。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) { 
         //set
        unordered_set<int> result_set;
        unordered_set<int> jiaoji(nums1.begin(),nums1.end());
        for(int i = 0;i<nums2.size();i++)
        {

            if(jiaoji.find(nums2[i])!=jiaoji.end())
            {
                result_set.insert(nums2[i]);
            }
        }
        vector<int> result(result_set.begin(),result_set.end());
        return result;
    }
};

思路：利用vector容器构造哈希表，由于数组的范围是有限的，可以构造一个有限长的哈希表。先将数组1，放入哈希表，之后遍历数组2，查找哈希表中是否有和数组2中的元素相同的元素，如果有，储存到新的数组里，遍历结束后，返回新的数组。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
            //数组
            int hash[1002] = {0};
            unordered_set<int> result_set;
            for(int i =0;i<nums1.size();i++)
            {
                hash[nums1[i]]++;
            }        
            for(int i =0;i<nums2.size();i++)
            {
                if (hash[nums2[i]]!=0)
                {
                    result_set.insert(nums2[i]);
                }
            }
            vector<int> result(result_set.begin(),result_set.end());
            return result;    
    }
};

202. 快乐数

思路：首先需要构造快乐数的求和函数，即将输入的数的每一位的平方求和。然后判断是否为快乐数，如果是快乐数，返回true，如果不是，将现在求和后的值判断是否已经在哈希表中，这里用set容器构造哈希表，因为如果哈希表中有该元素，说明已经进入死循环，不是快乐数。如果哈希表中不存在该元素，将该元素放入哈希表中，然后将该元素赋值给n,继续判断n是不是快乐数。

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) {

        unordered_set<int> sum_set;
    while(1){
        int sum  = getsum(n);
        if(sum==1)
        {
            return true;
        }
        else
        {
            if(sum_set.find(sum)!=sum_set.end())
            {
                return false;
            }
            else
            {
                sum_set.insert(sum);
            }
            n = sum;
        }
    }
    }
};

1. 两数之和

思路：遍历数组，建立哈希表，因为要求返回值是元素对应的索引，因此利用map容器构造哈希表比较方便，判断所需元素在不在哈希表中，如果在，可以获取到它的索引值。判断数组中的每一个数对应的target-nums[i]是否存在在哈希表中，如果存在，返回他们的索引。如果不在将这个元素及其它的索引存入哈希表，hash.insert(pair<int,int>(nums[i],i))。遍历完数组后，如果都不满足条件，返回{}.

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> num_set;
        for(int i;i<nums.size();i++)
        {   
            int iter = target - nums[i];
            auto index = num_set.find(iter);
            if(index!=num_set.end())
            {
                return {index->second,i};
            }
            else
            {
                num_set.insert(pair<int,int>{nums[i],i});
            }
        }
        return {};
 
    }
};