算法训练day5

 哈希表

有效的字母异位词

用数组模拟一个哈希映射的操作,

class Solution {
public:
    bool isAnagram(string s, string t) {

        //因为有26个字母,所以创建一个大小26的数组
        int result[26] = {};


        //每个字符-'a'的值就会映射到对应的数组下标上 然后++记录一下
        for(int i = 0; i < s.size();i++)
        {
            result[s[i] - 'a']++;
        }
        
        //检查t字符串有没有相同的字母, -- 一下
        for(int i = 0; i < t.size();i++)
        {
            result[t[i] - 'a']--;
        }

        //最后遍历数组如果有元素不等于0 就说明字两个字符串有不相等的元素
        for(int i = 0; i < 26; i++)
        {
            if(result[i] !=0)
            {
                return false;
            }
        }

        return true;

    }
};

349. 两个数组的交集

思路:用两个哈希表来解题,第一个哈希表用来去重第一个数组,然后用第一个哈希表去遍历第二个数组,如果有相同的元素就加入到第二个哈希表里面,最后返回第二个哈希表

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        //result表存放最后的结果
        unordered_set<int> result_set;
        //nums表用来去重第一个数组
        unordered_set<int> nums_set(nums1.begin(),nums1.end());
        for(int num : nums2)
        {   //然后用nums表来遍历第二数组,如果找到相同的就插入result表
            if(nums_set.find(num)!=nums_set.end())
            {
                result_set.insert(num);
            }
        }

        return vector(result_set.begin(),result_set.end());

    }
};

快乐数


 

这题的思路是找有没有重复的值,还有一个就是去每个数的个位数求出下一次循环的数是多少.

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;
        int sum = 0; 

        while(1)
        {
            sum = getsum(n);

            if(sum == 1)
            {
                return true;
            }

            if(set.find(sum) !=set.end())
            {
                return false;
            }
            else
            {
                set.insert(sum);
            }

            n = sum;
        }

        

    }
};

 

两数之和

为什么这道题要用哈希?当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

本题呢，我就需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是 是否出现在这个集合。

那么我们就应该想到使用哈希法了。

因为本地，我们不仅要知道元素有没有遍历过，还有知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。

接下来需要明确两点：

• map用来做什么
• map中key和value分别表示什么

map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）

接下来是map中key和value分别表示什么。

这道题 我们需要 给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标。

那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。

所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。

在遍历数组的时候，只需要向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查找,用target减去当前遍历数组元素,
            //如果减去的结果在map里面,返回当前的元素还有另外那个元素的下标
            auto it = map.find(target - nums[i]);
            if(it != map.end())
            {
                return {it->second,i};
            }
            else
            //如果没找到就把当前的元素插入,
            {
                map.insert(pair<int,int>(nums[i],i));
            }
        }
        return {};
        
    }
};