哈希表-算法总结

重邮研究森

已于 2022-09-15 10:52:30 修改

阅读量446

点赞数

分类专栏：算法总结文章标签：散列表数据结构

于 2022-09-15 10:51:42 首次发布

本文链接：https://blog.csdn.net/m0_60524373/article/details/126828411

版权

算法总结专栏收录该内容

8 篇文章 0 订阅

订阅专栏

哈希表理论基础

在做哈希表类型题目时，有三种数据结构：数组，set，map。

数组：用于数值小，范围小的情况，比如26个字母次数

set：用于数值较大

map：用于value映射为字符串时。比如班级同学名字

代码随想录 (programmercarl.com)https://programmercarl.com/%E5%93%88%E5%B8%8C%E8%A1%A8%E6%80%BB%E7%BB%93.html

有效的字母异位词

该类题目就是统计两个字符串的字母次数，由于26个字母数量较少，我们采用数组形式。

定义一个26大小的数组，且初始化为0

 vector<int> vec(26, 0);
 int record[26] = {0};

遍历第一个字符串，把字符串字母数量统计，再遍历第二个字符串，减去该字符串中的字母，再遍历数组，判断元素是否为0，因此整个代码如下：

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

    }
};

map版本

class Solution {
public:
    bool isAnagram(string s, string t) {
      unordered_map<char,int>map;
      for(auto &ch : s){
          map[ch]++;
      }
      for(auto &ch : t){
          map[ch]--;
      }
      for(auto num : map){
          if(num.second != 0){
              return false;
          }
      }
      return true;
    }
};

两个数组的交集

针对字符串中重复出现的数字，如果数字大小有规定则可以数组，否则set或者map

数组方法：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int>ans(1005,0);
        unordered_set<int>un_set;
        for(auto num : nums1){
            ans[num] = 1;
        }
        for(auto num : nums2){
            if(ans[num] == 1){
                un_set.insert(num);
            }
        }
        return vector<int>(un_set.begin(),un_set.end());
    }
};

set方法：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> ans;
        unordered_set<int> nums_set(nums1.begin(),nums1.end());//插入nums1到nums_set中
        //此时nums1中没有重复的元素，遍历nums2，看nums1中有没有
        for(auto num : nums2){
            if(nums_set.find(num) != nums_set.end()){
                ans.insert(num);
            }
        }
        return vector<int>(ans.begin(),ans.end());
    }
};

map方法：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        std::unordered_map<int, int> map;
        vector<int> ans;
        for (int i = 0; i < nums1.size(); i++) {
            map[nums1[i]] = 1;
        }

        for (int i = 0; i < nums2.size(); i++) {
            if (map[nums2[i]] == 1) {
                map[nums2[i]] = 0;
                ans.push_back(nums2[i]);
            }
        }
        return ans;
    }
};

快乐数

本题主要包括两个方面：求得每次的和，以及判断和是否重复。

定义一个求和函数，求得该数的平方和

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

对每次的结果进行为1判断，以及是否重复判断。

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>un_set;
        while(1){
            int sum = getSum(n);
            if( sum == 1){
                return true;
            }
            if(un_set.find(sum) != un_set.end()){
                //出现了这个数
                return false;
            }else{
                un_set.insert(sum);
            }
            n = sum;
        }
    }
};

两数之和

本题采用map因为：我们需要存放的是（元素，下标），因为存放两个值，所以不能用数组和set。

思路：

要找出两数之和是否等于目标值，可以利用哈希思想。

在遍历数组时，对于当前遍历元素，通过target-目标元素=需要元素，再判断之前的map中是否存在了需要元素，如果没有，继续向前遍历，同时把目标元素插进map中。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int>un_map;
        for(int i = 0; i < nums.size(); i++){
            int s = target - nums[i];
            auto iter = un_map.find(s);//找到返回迭代器，否则返回跌倒器最后位置空
            if(iter != un_map.end()){
                return {iter->second, i};
            }
            //没找到，把当前遍历元素插入map
            un_map.insert(pair<int, int>(nums[i], i));
        }
        return {};
    }
};

四数相加Ⅱ

本题的思想在于，把两个数组分成两部分，对第一部分求得一个和以及次数，第二部分也是如此，最后在遍历第二部分的时候，判断两部分的和是否相加为0，如果满足，就把第一部分该数的次数记录下来。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int>un_map;
        //统计1，2数组相加后的元素和以及次数
        for(auto x : nums1){
            for(auto y : nums2){
                un_map[x + y]++;
            }
        }
        int count = 0;//统计x+y+z+w=0的次数
        for(auto z : nums3){
            for(auto w : nums4){
                if(un_map.find(0 - (z + w)) != un_map.end()){
                    count += un_map[0 - (z + w)];
                }
            }
        }
        return count;
    }
};

三数之和

本题利用双指针思路解决。a+b+c=0

对原数组进行排序，这样方便我们比较结果是否=0，并且排序后的第一个元素如果>0，那么后面不用比较了。

    vector<vector<int>> ans;
    sort(nums.begin(),nums.end());
    //找到a+b+c=0，其中a固定位置，b为left，c为right
    for(int i = 0; i < nums.size(); i++){
        //如果起始位大于0，则不可能满足条件
        if(nums[i] > 0){
            return ans;
        }
}

对a进行去重，这时我们需要判断a与a前面一个元素而不是a和a的后一个元素，因为会漏掉 -1 -1 2这种情况

        //对a去重
        if(i > 0 && nums[i] == nums[i - 1]){
            continue;
        }

定义双指针，判断a+b+c的值和0的大小，大于就right左移，小于left右移，等于就把结果插入数组，并且指针移动

         int left = i + 1;
        int right = nums.size() - 1;
        while(right > left){
            //不用>= 是因为不满足求的三个元素，right不能是left
            if(nums[i] + nums[left] + nums[right] > 0){
                right--;
            }
            else if(nums[i] + nums[left] + nums[right] < 0){
                left++;
            }
            else{
                //a+b+c=0了
                ans.push_back(vector<int>{nums[i],nums[left],nums[right]});
                right--;
                left++;
        }

对b，c去重

                //对b。c去重
                while(right > left && nums[right] == nums[right - 1]){
                    right--;
                }
                while(right > left && nums[left] == nums[left + 1]){
                    left++;
                }

所有代码如下：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
    vector<vector<int>> ans;
    sort(nums.begin(),nums.end());
    //找到a+b+c=0，其中a固定位置，b为left，c为right
    for(int i = 0; i < nums.size(); i++){
        //如果起始位大于0，则不可能满足条件
        if(nums[i] > 0){
            return ans;
        }
        //对a去重
        if(i > 0 && nums[i] == nums[i - 1]){
            continue;
        }
        int left = i + 1;
        int right = nums.size() - 1;
        while(right > left){
            //不用>= 是因为不满足求的三个元素，right不能是left
            if(nums[i] + nums[left] + nums[right] > 0){
                right--;
            }
            else if(nums[i] + nums[left] + nums[right] < 0){
                left++;
            }
            else{
                //a+b+c=0了
                ans.push_back(vector<int>{nums[i],nums[left],nums[right]});
                //对b。c去重
                while(right > left && nums[right] == nums[right - 1]){
                    right--;
                }
                while(right > left && nums[left] == nums[left + 1]){
                    left++;
                }
                right--;
                left++;
            }
           
        }
    }
     return ans;
    }
};

四数之和

本题采用三数之和思路，这里只讲一下不特点。

除开双指针，多引入一个k，在i的前面，同时对k做和 i 做之前相同的剪纸和去重操作。

for(int k = 0;k < nums.size(); k++){
            //剪纸
            if(nums[k] > target && nums[k] >= 0){
                break;
            }
            //对nums[k]去重
            if(k > 0 && nums[k] == nums[k - 1]){
                continue;
            }
}

整个代码如下：

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>>ans;
        sort(nums.begin(),nums.end());
        for(int k = 0;k < nums.size(); k++){
            //剪纸
            if(nums[k] > target && nums[k] >= 0){
                break;
            }
            //对nums[k]去重
            if(k > 0 && nums[k] == nums[k - 1]){
                continue;
            }
            for(int i = k + 1; i < nums.size(); i++){
                //剪纸
                if(nums[k] + nums[i] > target && nums[k] + nums[i] >= 0){
                    break;
                }
                //对nums[i]去重
                if(i > k + 1 && nums[i] == nums[i - 1]){
                    continue;
                }
                //双指针
                int left = i + 1;
                int right = nums.size() - 1;
                while(right > left){
                    //对a++c+d和0关系判断
                    if((long)nums[k] + nums[i] + nums[left] + nums[right] > target){
                        right--;
                    }
                    else if((long)nums[k] + nums[i] + nums[left] + nums[right] < target){
                        left++;
                    }
                    else{
                        ans.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        while(right > left && nums[right] == nums[right - 1]){
                            right--;
                        }
                        while(right > left && nums[left] == nums[left + 1]){
                            left++;
                        }
                        right--;
                        left++;
                    }
                }
            }
        }
        return ans;
    }
};