LeetCode刷题——哈希表1

有效的字母异位词

题目链接.

• 题意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
• 思路：

1. 对两个字符串进行排序，比较排序之后的字符串是否相等，相等则互为字母异位词。

class Solution {
public:
    bool isAnagram(string s, string t) {
        sort(s.begin(),s.end());
        sort(t.begin(),t.end());
        return s==t;
    }
};

2. 使用哈希表，记录每个字符出现个数，比较出现个数是否相同，不同则不为字母异位词。

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(size(s)!=size(t)) return false;
        unordered_map<char,int> h;
        unordered_map<char,int> h1;
        for(auto ss:s){
            h[ss]++;
        }
        for(auto tt:t){
            h1[tt]++;
        }
        for(auto tt:t){
            if(h.find(tt)==h.end()) return false;
            else{
                if(h[tt]!=h1[tt]) return false;
            }
        }
        return true;
    }
};

两个数组的交集

题目链接.

• 题意：给定两个数组，编写一个函数来计算它们的交集。
• 思路：

1. 使用哈希表，记录第一个数组出现的数字，然后遍历第二个数组，数字在第一个数组出现过，添加到交集里，并且在哈希表删除该数字，防止出现重复元素，最后返回交集。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ans;
        unordered_set<int> h;
        for(auto n:nums1){
            if(h.find(n)==h.end()) h.insert(n);
        }
        for(auto n:nums2){
            if(h.find(n)!=h.end()){
                ans.push_back(n);
                h.erase(n);
            }
        }
        return ans;
    }
};

快乐数

• 题目链接.
• 题意：编写一个算法来判断一个数 n 是不是快乐数。
  「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。
• 思路：先定义一个函数，计算n每个位置上数字的平方和。定义一个哈希表，存储n，用n每个位置上数字的平方和替换n,当n==1时，返回true,当n已经在哈希表中出现过时，代表已经进入了无限循环当中，返回false。

class Solution {
public:
    bool isHappy(int n) {
        unordered_set<int> h;
        h.insert(n);
        while(1){
            n=summ(n);
            if(n==1) break;
            if(h.find(n)!=h.end()){
                return false;
            }
            else h.insert(n);
        }
        return true;


    }
    int summ(int n){
        int sum=0;
        while(n!=0){
            sum=sum+(n%10)*(n%10);
            n=n/10;
        }
        return sum;
    }
};

两数之和

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

1. （暴力解法）两层循环。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> a;
        int i,j,l,t;
        l=nums.size();
        for(i=0;i<l;i++){
            for(j=i+1;j<l;j++){
                if(nums[i]+nums[j]==target){
                    a.push_back(i);
                    a.push_back(j);
                    
                }
            }
        }
        return a;
    }
};

2. (哈希表)，用哈希表存储数组的值和它对应的下标，遍历数组，当遍历到nums[i]时，在哈希表中查找是否存在target-nums[i],存在则返回当前下标和target-nums[i]对应的下标，不存在则将nums[i]和对应的下标i加入哈希表中。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ans;
        unordered_map<int,int> h;
        h[nums[0]]=0;
        for(int i=1;i<size(nums);++i){
            if(h.find(target-nums[i])!=h.end()){
                ans.push_back(h[target-nums[i]]);
                ans.push_back(i);
            }
            else h[nums[i]]=i;
        }
        return ans;
    }
};

四数相加 II

• 题目链接
• 题意：给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。
• 思路：分组+哈希表，遍历AB将A[i]+B[j]的所有值记录到哈希表中，遍历CD，查找-C[i]-D[j]在哈希表中对应的值，累加得到结果。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> h;
        int ans=0;
        for(int i=0;i<size(nums1);++i){
            for(int j=0;j<size(nums2);++j){
                h[nums1[i]+nums2[j]]++;
            }
        }
        for(int i=0;i<size(nums1);++i){
            for(int j=0;j<size(nums2);++j){
                if(h.find(-nums3[i]-nums4[j])!=h.end()){
                    ans=ans+h[-nums3[i]-nums4[j]];
                }
            }
        }
        return ans;
    }
};