代码随想录Day6—— 哈希表：242.有效的字母异位 349. 两个数组的交集 202. 快乐数 1. 两数之和

最新推荐文章于 2024-07-25 15:54:48 发布

cheng_dog

最新推荐文章于 2024-07-25 15:54:48 发布

阅读量1.6k

点赞数

文章标签：散列表数据结构

本文链接：https://blog.csdn.net/cheng_dog/article/details/134122754

版权

哈希表：判断一个量是否在某个容器中存在/遍历过

242.有效的字母异位

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

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

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

string：string是C++风格的字符串，而string本质上是一个类，字符串中元素（字符）的获取[i]或.at(i);
哈希表：以本题为例定义哈希数组，hash[0]代表字母a出现的次数，字母a出现一次hash[0]加一，这样判断一个字符串中不同字母出现的次数。

349. 两个数组的交集

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

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for (int num : nums2) 
        //int num;
        //for(int i = 0;i<nums2.size();i++)
        {
            // 发现nums2的元素 在nums_set里又出现过
            //num = nums2[i];
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

for (int num : nums2) 
        //int num;
        //for(int i = 0;i<nums2.size();i++)
            //num = nums2[i];

注释部分与非注释部分等价

set：set（有序，元素不可重复）unordered_set（无序，元素不可重复）multiset（有序，元素可重复）

set和vector的的构造与相互转化：

       unordered_set<int> nums_set(nums1_vector.begin(), nums1_vector.end());
       vector<int> result(result_set.begin(), result_set.end());

find函数：查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end()/map.end()/string.end()等;

202. 快乐数

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

「快乐数」 定义为：

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

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

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;
            }
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            if (set.find(sum) != set.end()) {
                return false;
            } else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

取各位的数字的方法，循环除10取余和除10取商
判断陷入无限循环的条件，本题是重复出现一个数字，所以可以使用哈希表。

1. 两数之和

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

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

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

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> num;
        int search;
        vector<int> result;
        for(int i = 0;i<nums.size();i++)
        {
            search = target - nums[i];
            if(num.find(search) != num.end())
            {
                result.insert(result.begin(),num.find(search)->second);
                result.insert(result.begin()++,i);
                return result;
            }
            num.insert(pair<int, int>(nums[i], i));
        }
        return result;
    }
};

map：map（有序，元素不可重复）unordered_map（无序，元素不可重复）multimap（有序，元素可重复）

map的构造与查找：

        unordered_map<int,int> num;
        num.insert(pair<int, int>(nums[i], i));
        num.find(search)->first//key值
        num.find(search)->second//value值