【算法】哈希表

个人主页 ： zxctscl
如有转载请先通知

题目

[1. 1. 两数之和](#1. 1. 两数之和)
- [1.1 分析](#1.1 分析)
- [1.2 代码](#1.2 代码)
[2. 面试题 01.02. 判定是否互为字符重排](#2. 面试题 01.02. 判定是否互为字符重排)
- [2.1 分析](#2.1 分析)
- [2.2 代码](#2.2 代码)
[3. 217. 存在重复元素](#3. 217. 存在重复元素)
- [3.1 分析](#3.1 分析)
- [3.2 代码](#3.2 代码)
[4. 219. 存在重复元素 II](#4. 219. 存在重复元素 II)
- [4.1 分析](#4.1 分析)
- [4.2 代码](#4.2 代码)
[5. 49. 字母异位词分组](#5. 49. 字母异位词分组)
- [5.1 分析](#5.1 分析)
- [5.2 代码](#5.2 代码)

1. 1. 两数之和

1.1 分析

这里题目所述非常清楚，就求两个数的和，可以直接用暴力解法：先固定一个数然后找另一个数。但这样的方式来用哈希表优化，可能就会出现某一个数被找了两次，还得再判断一下，就比较麻烦。

而另一种暴力解法就是，先固定一个数，然后找他前面的数来判断是否和等于目标值，这种暴力解法可以使用哈希表来做优化，之前固定过的数据都是考虑过得，就不会出现重复的数字。

先固定一个数然后找它前面的数，可以把它前面的数都存在哈希表里面。第一个数前面没有数，就先把这个是放在哈希表里面，然后继续移动到下一个数，继续在哈希表里面找值。但是因为要找下标，就把下标和值一起存在哈希表里面。

1.2 代码

cpp 复制代码

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int>hash;
        for(int i=0;i<nums.size();i++)
        {
            int x=target-nums[i];
            if(hash.count(x))return{hash[x],i};
            hash[nums[i]]=i;
        }
        return {-1,-1};
    }
};

2. 面试题 01.02. 判定是否互为字符重排

2.1 分析

一、题目解析

题目要求只有小写字母，只要比较两个字符串里面的每个字符个数相同就可以判断两个字符是不是互为字符重排。

二、算法原理

要保存字符和对应字符出现的值，就用到哈希表。

只有小写字母，只需要开26个大小的数组，只统计s1中每个字符出现的个数就行，来遍历s2时候在哈希表中出现对应的字符就减掉1就可以，只要哈希表里面全部为0就可以，但如果s2中出现的某一个字符，在哈希表里面被减成了负数，就直接返回false就可以。如果两个字符串的长度不相等，那么就直接返回false就可以。

2.2 代码

cpp 复制代码

class Solution {
public:
    bool CheckPermutation(string s1, string s2) {
     if(s1.size()!=s2.size())return false;
     int hash[26]={0};
     for(auto ch:s1)
     {
        hash[ch-'a']++;
     }
     for(auto ch:s2)
     {
        hash[ch-'a']--;
        if(hash[ch-'a']<0)return false;
     }
     return true;

    }
};

3. 217. 存在重复元素

3.1 分析

一、题目解析

只要题目中出现相同的数就返回true。

二、算法原理

只需要固定当前的值，然后把它前面的值放在哈希表里面，判断一下哈希表里面有没有这个数，有就返回true，没有就返回false。

3.2 代码

cpp 复制代码

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
     unordered_set<int>hash;
        for(auto x:nums)
        {
            if(hash.count(x))return true;
            else hash.insert(x);
        }
        return false;
    }
};

4. 219. 存在重复元素 II

4.1 分析

一、题目解析

和上面的一题类似，这里就多了一个下标的判断，如果下标的差值小于等于某一个数就返回true，否则就返回false。

二、算法原理

固定一个值，把它前面一个值的下标和值都放在哈希表里面，当在它前面找到这个数的时候就把下标拿出来，比较差值，大于规定的值，就把这个数继续放在哈希表里面。

但是可能会出现一个情况，出现相同的元素，但是下标不一样，可能会吧哈希表里面的值覆盖掉，可题目中找的是小于等于某一个值，所以就直接找最近的值，所以是可以覆盖掉哈希表之前相同的值。

4.2 代码

cpp 复制代码

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        unordered_map<int,int>hash;
        for(int i=0;i<nums.size();i++)
        {
            if(hash.count(nums[i]))
            {
                if(i-hash[nums[i]]<=k)return true;
            }
            hash[nums[i]]=i;
        }
        return false;
    }
};

5. 49. 字母异位词分组

5.1 分析

互为字⺟异位词的单词有⼀个特点：将它们排序之后，两个单词应该是完全相同的。

所以，我们可以利⽤这个特性，将单词按照字典序排序，如果排序后的单词相同的话，就划分到同一组中。

这时我们就要处理两个问题：

排序后的单词与原单词需要能互相映射；
将排序后相同的单词，划分到同一组；

定义一个哈希表:将排序后的字符串string当做哈希表的 key 值；将字母异位词数组string[]当成 val 值。

5.2 代码

cpp 复制代码

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
      unordered_map<string, vector<string>>hash;
      int n=strs.size();
     for(auto s:strs)
     {
        string tmp=s;
        sort(tmp.begin(),tmp.end());
       hash[tmp].push_back(s);
     }
     vector<vector<string>> ret;
     for(auto&[x,y]:hash)
     {
        ret.push_back(y);
     }
     return ret;


    }
};

有问题请指出，大家一起进步！！！