【LeetCode】哈希表合集

最新推荐文章于 2020-10-12 09:10:11 发布

lifecookies

最新推荐文章于 2020-10-12 09:10:11 发布

阅读量158

点赞数

分类专栏： LeetCodes解题

本文链接：https://blog.csdn.net/qq_37581730/article/details/108429219

版权

LeetCodes解题专栏收录该内容

51 篇文章 1 订阅

订阅专栏

当需要判断一个元素是否出现过的时候，就考虑哈希表

1. 哈希表的本质是空间换时间，通过数组，set，map将数据已经预处理
2. set的限制是只能存放单一key，不能记录更多的数据
3. 进而考虑map，map通过<key,value>的存储数据，允许我们更加灵活的存储哈希值和对应的数值

383. 赎金信

383. 赎金信
给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)
注意：
你可以假设两个字符串均只含有小写字母。

canConstruct("a", "b") -> false
canConstruct("aa", "ab") -> false
canConstruct("aa", "aab") -> true

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        if(ransomNote.size()==0) return true;
        if(magazine.size()==0) return false;
        
         
        if(ransomNote.size()>magazine.size()) return false;

        auto it=magazine.begin();
        unordered_map<int,int> m_map;
        while(it!=magazine.end()){
            char tmp=*it;
            m_map[tmp]++;
            it++;
        }
        auto rit=ransomNote.begin();
        while(rit!=ransomNote.end()){
            char tmp=*rit;
            if(m_map[tmp]!=0)
            m_map[tmp]--;
            else return false;
            rit++;
        }
        return true;

    }
};

575. 分糖果

575. 分糖果
给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。

示例 1:

输入: candies = [1,1,2,2,3,3]
输出: 3
解析: 一共有三种种类的糖果，每一种都有两个。
     最优分配方案：妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。
示例 2 :

输入: candies = [1,1,2,3]
输出: 2
解析: 妹妹获得糖果[2,3],弟弟获得糖果[1,1]，妹妹有两种不同的糖果，弟弟只有一种。这样使得妹妹可以获得的糖果种类数最多。
注意:

数组的长度为[2, 10,000]，并且确定为偶数。
数组中数字的大小在范围[-100,000, 100,000]内。

class Solution1 {//哈希表 两次遍历时间复杂度O（N）
public:
    int distributeCandies(vector<int>& candies) {
        int size=candies.size();
        if(size==0) return 0;

        auto it=candies.begin();
        unordered_map<int,int> um;
        while(it!=candies.end()){
            um[*it]++;
            it++;
        }

        auto mit=um.begin();
        int sigle=0;
        int multi=0;
        while(mit!=um.end()){
            if(mit->second>1)
            multi++;
            else
            sigle++;
            mit++;
        }

        if(sigle+multi>=size/2)
        return size/2;
        else
        return sigle+multi;

    }
};
class Solution {//哈希表 两次遍历时间复杂度O（N）第二次遍历并不需要单个的和多个的具体数目
public:
    int distributeCandies(vector<int>& candies) {
        int size=candies.size();
        if(size==0) return 0;

        auto it=candies.begin();
        unordered_map<int,int> um;
        while(it!=candies.end()){
            um[*it]++;
            it++;
        }

       // auto mit=um.begin();
       // int sigle=0;
       // int multi=0;
       // while(mit!=um.end()){
        //    if(mit->second>1)
        //    multi++;
        //    else
         //   sigle++;
         //   mit++;
        //}

        if(um.size()>=size/2)
        return size/2;
        else
        return um.size();

    }
};


class Solution3 {//事实上两边遍历map就是初始化set的过程
public:
    int distributeCandies(vector<int>& candies) {
        int size=candies.size();
        //if(size==0) return 0;
        unordered_set<int> is(candies.begin(),candies.end());
        return size/2>is.size()?is.size():size/2;
    }
};

349. 两个数组的交集

349. 两个数组的交集
给定两个数组，编写一个函数来计算它们的交集。

 

示例 1：

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

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
 

说明：

输出结果中的每个元素一定是唯一的。
我们可以不考虑输出结果的顺序。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int len1=nums1.size();
        int len2=nums2.size();
      //  vector<int> res;

             //  for(int i=0;i<nums1.size();i++){ }
             // for(int i=0;i<len1;i++){
             //    for(int j=0;j<len2;j++){
             //        if(nums2[j]==nums1[i]){
             //           res.push_back(nums1[i]);
             //           break;
             //       }
             //   }
             //}

         unordered_set<int> nums1_set(nums1.begin(),nums1.end());
         unordered_set<int> ans;
         for(auto num:nums2){
             if(nums1_set.count(num)==1)
             ans.insert(num); 
         }


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


    }
};

202. 快乐数

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

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为  1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

 

示例：

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

class Solution {
public:
    bool isHappy(int n) {
        int ans=n;
        unordered_set<int> us;
        us.insert(n); 
        while(ans!=1){
            string s_ans=to_string(ans);
            int sum=0;
            for(auto c:s_ans){
                int tmp=c-48;
                sum+=tmp*tmp;
            }
            if(us.count(sum)<1)
             us.insert(sum); 
            else return false;
            ans=sum;
        }
        return true;
    }
};

1. 两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

 

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
通过次数1,350,215提交次数2,736,274

class Solution1 {//暴力法
public:
    vector<int> twoSum(vector<int>& nums, int target) {
       vector<int> a;
       for(int i=0;i<nums.size()-1;i++){
       for(int j=i+1;j<nums.size();j++){

       if(nums[i]+nums[j]==target){
        a.push_back(i);
        a.push_back(j);
}
       }
       }
return a;
       }
    };

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

       }
    };

274. H 指数

274. H 指数
给定一位研究者论文被引用次数的数组（被引用次数是非负整数）。编写一个方法，计算出研究者的 h 指数。
h 指数的定义：h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （N 篇论文中）总共有 h 篇论文分别被引用了至少 h 次。（其余的 N - h 篇论文每篇被引用次数 不超过 h 次。）
例如：某人的 h 指数是 20，这表示他已发表的论文中，每篇被引用了至少 20 次的论文总共有 20 篇。

示例：
输入：citations = [3,0,6,1,5]
输出：3 
解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。
     由于研究者有 3 篇论文每篇 至少 被引用了 3 次，其余两篇论文每篇被引用 不多于 3 次，所以她的 h 指数是 3。
提示：如果 h 有多种可能的值，h 指数是其中最大的那个。
通过次数16,308提交次数41,963

class Solution {
public:
    int hIndex(vector<int>& citations) {
      sort(citations.begin(),citations.end());
      for(int i=0;i<citations.size();i++){
          int h=citations.size()-i;
          if(h<=citations[i])
          return h;
      }
      return 0;
    }
};

lifecookies

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【LeetCode】哈希表合集

当需要判断一个元素是否出现过的时候，就考虑哈希表1. 哈希表的本质是空间换时间，通过数组，set，map将数据已经预处理2. set的限制是只能存放单一key，不能记录更多的数据3. 进而考虑map，map通过<key,value>的存储数据，允许我们更加灵活的存储哈希值和对应的数值383. 赎金信383. 赎金信给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果
复制链接

扫一扫

专栏目录