day6 | 关于哈希表

最新推荐文章于 2024-07-20 09:51:47 发布

love-lalisa

最新推荐文章于 2024-07-20 09:51:47 发布

阅读量92

点赞数

分类专栏：力扣 c++ 文章标签：算法 c++ 数据结构

本文链接：https://blog.csdn.net/weixin_53148080/article/details/127622016

版权

力扣同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

c++

12 篇文章 0 订阅

订阅专栏

哈希表理论基础

一般哈希表都是用来快速判断一个元素是否出现集合里

在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示：

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(logn)	O(logn)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

std::unordered_set底层实现为哈希表，std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。

------所有元素只有key没有value，value就是key

当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。

----------刷题常用函数

insert() 插入一个值

map.find(x) != map.end()[说明集合中包含这个元素]

map.end()返回最后一个元素的迭代器

vector(result.begin(),result.end());直接将集合转换为数组

242.有效的字母异位词

题目

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

示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true

示例 2: 输入: s = “rat”, t = “car” 输出: false

说明: 你可以假设字符串只包含小写字母。

题解

这道题考察的主要就是：

数组就是一种特殊的哈希结构，下标为哈希值
字母我们可以用 ‘x’- 'a’来转化x的下标为 0~26

class Solution {
public:
    bool isAnagram(string s, string t) {
          
          int record[26] =  {0};  //对应26个小写字母

          for(int i = 0;i < s.size();i++){
              int index = s[i] - 'a';
              record[index] ++;
          }

          for(int i = 0;i < t.size();i++){
              int index = t[i] - 'a';
              record[index]--;
          }

          for(int i = 0;i < 26;i++){
              if(record[i] != 0){
                  return false;
              }
          }
      return true;



    }
};

349.俩个数组的交集

题目

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

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

题解

这道题目主要是考察 set集合的使用，

用到了set的特性，要熟悉三种不同的set结构的作用和用法，见理论知识

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
            //当题目中没有限制数据的大小时，我们不能使用数组作为hash结构

            unordered_set<int> result ;
            unordered_set<int> set1;

            for(int num:nums1){
                set1.insert(num);
            }
            for(int num:nums2){
                if(set1.find(num) != set1.end()){
                    result.insert(num);
                }
            }

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

    }
};

题目限定了数组范围，我们可以使用数组作为哈希结构

妙处：record【num】 = 1 （而不是++）；

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
                 
       unordered_set<int> result;
        int record[1002] = {0};
        for(int num:nums1){
            record[num] = 1;  //等于1而不是++的好处就是可以直接去掉nums1中的重复元素
        }

        for(int num:nums2){
            if(record[num] == 1){
            result.insert(num);
            }
        }
    return vector<int>(result.begin(),result.end());

    }
};

202.快乐数

题目

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

「快乐数」定义为：

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

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

题解

我们在审题的时候，要非常注意题目当中的关键字，

这道题中，无限循环就很重要，我们得判断什么时候发生了无限循环，【即sum求和中，sum会出现重复的值】，这样，我们就可以把题解往哈希方向上来想
其次，这道题重要的是如何求每一位的平方和，思想是先求个位，再求高位，然后每次都相加，直到n变为0 【8/10 = 0】

class Solution {
public:
   //求和的过程

   int getSum(int n){
        int sum = 0;
        
       while(n != 0){
        sum += (n % 10) * (n % 10); //取个位数相乘并相加
        n = n / 10; //将高位变成低位，求平方和
       }
       return sum;
   }


    bool isHappy(int n) {
       //审题：当无限循环时候怎么处理【即求和的时候，sum会重复出现】
        unordered_set<int> record; 
       //判断一个数是否重复出现，我们可以用unorderd_set
       
       while(1){
           int sum = getSum(n);
           if(sum == 1){
               return true;
           }
           if(record.find(sum) != record.end()){
               return false;
           }else{
               record.insert(sum);
           }

           n = sum;

       }

    
    }
};

1.俩数之和

题目

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

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

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

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

题解

1.很显然，双重for循环暴力枚举，可以ac

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
         //第一种，很显然，双重for循环暴力
 
         for(int i = 0; i < nums.size();i++){
             for(int j = i + 1 ;j < nums.size();j++){
                 if(nums[i] + nums[j] == target){
                     return {i,j};
                 }
             }
         }
         return {0,0};
    }
};

2.但是，暴力显然面试不敢写，

我们可以先遍历数组，将值放入哈希表，当 target - nums【i】的值出现在哈希表结构当中时候，说明nums[i] + 哈希表结构当中的那个值 = 目标值

这里我们还要考虑的是如何知道哈希表结构中的那个值的下标【因为题目要求返回下标】，所以，我们可以使用那个数为key，下标为value的hashmap结构

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
         unordered_map<int ,int> record;

         for(int i = 0; i < nums.size();i++){
            auto iter = record.find(target - nums[i]);
            //先判断之前的集合里有没有出现想要的值，有返回，没有插入，继续遍历
             if( iter != record.end()) {
                 return {i,record[target - nums[i]]};
             }
             record[nums[i]] = i;
         }
              return {0,0};




    }
};