2021-08-21-22 哈希表

最新推荐文章于 2022-03-05 20:05:32 发布

WWF_666

最新推荐文章于 2022-03-05 20:05:32 发布

阅读量278

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/wwf_5450/article/details/119845859

版权

笔记专栏收录该内容

20 篇文章 0 订阅

订阅专栏

本文介绍了C++中几种常见的算法实现，包括检查字母异位词、查找常用字符、计算数组交集、解决两数之和问题、求四数之和的计数、判断赎金信是否可行以及寻找三数之和。这些算法涉及到字符串处理、数组操作、哈希映射等数据结构和技巧，对于提升C++编程能力非常有帮助。

摘要由CSDN通过智能技术生成

1.有效的字母异位词

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26]={0};
        for(int i=0;i<s.size();i++){//遍历s
            record[s[i]-'a']++;
        }
        for(int i=0;i<t.size();i++){//遍历t
            record[t[i]-'a']--;
        }
        for(int i=0;i<26;i++){//遍历record
            if(record[i]!=0){//若存在不为0的元素则说明字符不一样
                return 0;
            }
        }
        return 1;
    }
};

2.查找常用字符

string s(1,i+'a');//s为1个ascall码为i+'a'字符组成的字符串，["e","l","l"]

string s(2,i+'a');//若改为2，则题目输出结果["ee","ll","ll"]

上面这个用法第一次接触

class Solution {
public:
    vector<string> commonChars(vector<string>& words) {
        vector<string> ans;//可变长数组存放结果
        if(words.size()==0){
            return ans;
        }
        int hash[26]={0}; //存放字母出现最小次数
        //用第一个字符串初始化hash便于比较
        for(int i=0;i<words[0].size();i++){
            hash[words[0][i]-'a']++;
        }
        int hashOther[26];//存放除第一个字符串外字母出现次数
        //遍历其他字符串与hash比较
        for(int i=1;i<words.size();i++){
            memset(hashOther,0,sizeof(hashOther));//每遍历一个字符串需要重新置0
            for(int j=0;j<words[i].size();j++){
                hashOther[words[i][j]-'a']++;
            }
            for(int k=0;k<26;k++){
                hash[k]=min(hash[k],hashOther[k]);//更新hash
            }
        }
        //输出hash中有值的字母
        for(int i=0;i<26;i++){
            while(hash[i]!=0){
                string s(1,i+'a');//将i转换为字母的ascall码
                ans.push_back(s);//vector的元素插入
                hash[i]--;
            }
        }
        return ans;
    }
};

3.两个数组的交集

unordered_set并不需要对数据进行排序，而且还不要让数据重复

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> res;
        unordered_set<int> cmp(nums1.begin(),nums1.end());
        for(int num:nums2){
            if(cmp.find(num)!=cmp.end()){
                res.insert(num);//num2的元素在cmp里出现过则插入res
            }
        }
        return vector<int>(res.begin(),res.end());//以数组格式输出
    }
};

4.两数之和

auto在声明变量的时候可根据变量初始值的数据类型自动为该变量选择与之匹配的数据类型。用于代替冗长复杂、变量使用范围专一的变量声明。

it->second指value, it->first指key

map的元素类型是pair<int,int>

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> map;
        for(int i=0;i<nums.size();i++){
            auto it=map.find(target-nums[i]);
            if(it!=map.end()){//若差值在map中则可以返回答案
                return {it->second,i};
            }
            map.insert(pair<int,int>(nums[i],i));//若不在则以{key,value}插入
        }
        return {};
    }
};

5.四数相加 II

end()返回的是最后一个元素的下一个位置

find(x)返回的是key=x的value

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> map;
        for(int a:nums1){//遍历AB数组，key=a+b,value=a+b出现次数
            for(int b:nums2){
                map[a+b]++;
            }
        }
        int count=0;
        for(int c:nums3){//遍历CD，如果0-(c+d)在map中出现就说明四数和为0，统计次数
            for(int d:nums4){
                if(map.find(0-c-d)!=map.end()){
                    count+=map[0-c-d];
                }
            }
        }
        return count;
    }
};

6.赎金信

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int rec[26]={0};
        for(int i=0;i<magazine.size();i++){//先遍历杂志记录各字母能出现的次数
            rec[magazine[i]-'a']++;
        }
        for(int i=0;i<ransomNote.size();i++){//遍历赎金信
            rec[ransomNote[i]-'a']--;
            if(rec[ransomNote[i]-'a']<0){//若小于0说明杂志的字母不够
                return 0;
            }
        }
        return 1;
    }
};

7.三数之和

去重理解了很久

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector< vector<int> > res;//结果是存储几个元组的数组
        sort(nums.begin(),nums.end());//升序排序,a+b+c=nums[i]+nums[l]+nums[r]
        for(int i=0;i<nums.size();i++){
            if(nums[i]>0){//第一个元素若大于零则不可能和为零
                return res;
            }
            if(i>0 && nums[i]==nums[i-1]){//nums[i]的去重,i指针只指向第一个
                continue;
            }
            int l=i+1;
            int r=nums.size()-1;
            while(l<r){
                if(nums[i]+nums[l]+nums[r]>0){//若大于0，r应向左让和小一些
                    r--;
                }
                else if(nums[i]+nums[l]+nums[r]<0){//若小于0，l应向右移让和大一些
                    l++;
                }
                else{
                    res.push_back(vector<int> {nums[i],nums[l],nums[r]});
                    //在找到第一个元组后才开始去重，防止漏掉{0，0，0}的可能
                    while(l<r && nums[r]==nums[r-1]){//nums[r]的去重
                        r--;
                    }
                    while(l<r && nums[l]==nums[l+1]){//nums[l]的去重
                        l++;
                    }
                    r--;//找到后双指针同时收缩，单独移动不成立，只改变一个和必然不为零
                    l++;
                }
            }
        }
        return res;en
    }
};

8.四数之和

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector< vector<int> > res;
        sort(nums.begin(),nums.end());
        // if(nums.size()<4){
        //     return res;
        // }
        for(int i=0;i<nums.size();i++){
            if(i>0 && nums[i]==nums[i-1]){
                continue;
            }
            // if(nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target){
            //     break;
            // }//仅提供思路
            for(int j=i+1;j<nums.size();j++){
                if(j>i+1 && nums[j]==nums[j-1]){
                    continue;
                }
                int l=j+1;
                int r=nums.size()-1;
                while(l<r){
                    if(nums[i]+nums[j]>target-(nums[l]+nums[r])){
                        r--;
                    }
                    //与nums[i]+nums[j]+nums[l]+nums[r]>target的区别???
                    else if(nums[i]+nums[j]<target-(nums[l]+nums[r])){
                        l++;
                    }
                    else{
                        res.push_back(vector<int> {nums[i],nums[j],nums[l],nums[r]});
                        while(l<r && nums[r]==nums[r-1]){
                            r--;
                        }
                        while(l<r && nums[l]==nums[l+1]){
                            l++;
                        }
                        r--;
                        l++;
                    }
                }
            }
        }
        return res;
    }
};