代码随想录算法训练营第六天| 哈希表理论基础 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和

合集 - 代码训练(55)

1.代码随想录算法训练营第一天| 704. 二分查找、27. 移除元素。2024-01-24 2.代码随想录算法训练营第二天|977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II2024-01-25 3.代码随想录算法训练营第三天| 203.移除链表元素，707.设计链表，206.反转链表2024-01-26 4.代码随想录算法训练营第四天| 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 142.环形链表II2024-01-27

5.代码随想录算法训练营第六天| 哈希表理论基础 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和2024-01-29

哈希表理论基础

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1: 输入: s = "anagram", t = "nagaram" 输出: true

示例 2: 输入: s = "rat", t = "car" 输出: false

说明: 你可以假设字符串只包含小写字母。

题目链接：242. 有效的字母异位词 - 力扣（LeetCode）

下面是哈希数组的思路

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

还可以用哈希表的方法，注意字符串的遍历方式。

  bool isAnagram(string s, string t) {
        if (s.length() != t.length()) {
            return false;
        }
        vector<int> table(26, 0);
        for (auto& ch: s) {
            table[ch - 'a']++;
        }
        for (auto& ch: t) {
            table[ch - 'a']--;
            if (table[ch - 'a'] < 0) {
                return false;
            }
        }
        return true;
    }

以及排序的方法：

 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. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是唯一的。我们可以 不考虑输出结果的顺序 。

题目链接：349. 两个数组的交集 - 力扣（LeetCode）

思路：将两个vector放进set中，再比较set即可。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        set<int> a;
        set<int> b;
        for(int i=0;i<nums1.size();i++){
            a.insert(nums1[i]);
        }
        for(int i=0;i<nums2.size();i++){
            b.insert(nums2[i]);
        }
        vector<int>  count;
        for(auto i=a.begin();i!=a.end();i++){
            if(b.find(*i)!=b.end()){
                count.push_back(*i);
            }
        }
        return count;
    }
};

甚至我们只用一个set容器也能解决问题，注意学习这种set容器初始化方法：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;
        /* 由于输出的元素唯一不重复因此可以将nums1转化为unordered_set哈希表 */
        unordered_set<int> nums1_set(nums1.begin(),nums1.end());
        for(int i = 0; i < nums2.size(); i++){
            /* 判断nums1_set中是否有nums2的元素，若有将此值插入到result */
            if(nums1_set.find(nums2[i]) != nums1_set.end())
                result.insert(nums2[i]);
        }
        return vector<int> (result.begin(),result.end());
    }
};

202.快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

题目链接：202. 快乐数 - 力扣（LeetCode）

思路：

由于sum可能重复出现，所以这就是我们跳出无限循环的标志，用set存储sum，当出现重复就表示进入死循环。

class Solution {
public:
    bool isHappy(int n) {
        int sum=0;
        set<int>result;
        result.insert(0);
        while(1){
            while(n>0){
                sum+=(n%10)*(n%10);
                n/=10;
            }
            if(sum==1)
            return true;

            if(result.find(sum)!=result.end())
                return false;
            result.insert(sum);
            n=sum;
            sum=0;
        }
    }
};

但评论区还有一种用双指针的判断循环思路，虽然说会慢一些，但是保证能完成任务，set可能大到无法存储。

class Solution {
public:
    int bitSquareSum(int n) {
        int sum = 0;
        while(n > 0)
        {
            int bit = n % 10;
            sum += bit * bit;
            n = n / 10;
        }
        return sum;
    }
    
    bool isHappy(int n) {
        int slow = n, fast = n;
        do{
            slow = bitSquareSum(slow);
            fast = bitSquareSum(fast);
            fast = bitSquareSum(fast);
        }while(slow != fast);
        
        return slow == 1;
    }
};

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

题目链接：1. 两数之和 - 力扣（LeetCode）

思路：用map存储数组，遍历数组再查找map中有无对应答案。这里其实只用到了map的find功能，而且操作了两次哈希表。

注意：map的find函数查找的是key，不是value！！！

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int> a;
        for(int i=0;i<nums.size();i++){
        a.insert(pair<int,int>(nums[i],i));    //注意顺序
        }
        for(int i=0;i<nums.size();i++){
            auto iter=a.find(target-nums[i]);
            if(iter!=a.end()&&iter->second!=i){
//                result.push_back(i);
//                result.push_back(iter->first);
            return {i,iter->second};            //更简洁的返回方式
            }
        }
        return {};
    }
};

更加优化的写法，只用一遍哈希：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::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 {};
    }
};