代码随想录Day6：哈希

最新推荐文章于 2024-07-22 04:47:17 发布

wertvoll

最新推荐文章于 2024-07-22 04:47:17 发布

阅读量51

点赞数

文章标签：哈希算法 leetcode 算法

本文链接：https://blog.csdn.net/weixin_45845722/article/details/128602403

版权

哈希

242 有效的字母异位词

题目描述

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

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

代码

法一：排序
法二：哈希。先判断 s 和 t 长度是否相等，再更新26个字母对应的record[]。

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;
        
        //哈希
        int record[26] = {0};
        if(s.size() != t.size())
        {
            return false;
        }
        for(int i = 0; i< s.size(); i++)
        {
            record[s[i]-'a']++;
        }
        for(int i = 0; i < t.size(); i++)
        {
            record[t[i]-'a']--;
            if(record[t[i]-'a'] < 0)
            {
                return false;
            }
        }
        return true;
    }
};

复杂度

排序：
时间复杂度：O(nlog⁡n)，其中 n 为 s 的长度。
空间复杂度：O(log⁡n)。

哈希：
时间复杂度：O(n)，其中 n 为 s 的长度。
空间复杂度：O(S)，其中 S 为字符集大小，此处 S=26。

349 两个数组的交集

题目描述

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

代码

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        //创建unordered的2种方法（共4种）
        unordered_set<int> res;
        unordered_set<int> nums_set(nums1.begin(),nums1.end());

        int num;
        for(int i = 0; i<nums2.size();i++)
        {
            num = nums2[i];
            if(nums_set.find(num) != nums_set.end())
            {
                res.insert(num);
            }
        }

        return vector<int>(res.begin(),res.end());
    }
};

补充

unordered_set
return 语句的vector没有变量名

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 = n/10;
        }
        return sum;
    }

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

待补充

快慢指针法

1 两数之和

题目描述

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

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

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

代码

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> map;
        for(int i = 0; i < nums.size(); i++)
        {
            int diff = target - nums[i];
            //要取元素的index，故单独定义iter
            auto iter = map.find(diff);
            if(iter != map.end())
            {
                return {i,iter->second};
            }
            else
            {
                map.insert(pair<int,int>(nums[i],i));
            }
        }
        return {};
    }
};