三、查找表（1 简单示例）

最新推荐文章于 2022-12-21 14:05:04 发布

housz77

最新推荐文章于 2022-12-21 14:05:04 发布

阅读量246

点赞数

分类专栏： liu算法刷题学习文章标签： leetcode stl c++ 算法

本文链接：https://blog.csdn.net/housz77/article/details/114449409

版权

liu算法刷题学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

这篇博客介绍了多种数据结构和算法在解决实际问题中的应用，如查找表在寻找两个数组交集、字母异位词判断、快乐数检测以及单词规律匹配中的使用。通过集合、映射等数据结构实现高效解决方案，并展示了如何通过排序优化字符串排序和频率排序。这些算法在提高代码效率和解决复杂问题方面具有重要作用。

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

三、查找表（简单示例）

349. 两个数组的交集

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        set<int> record(nums1.begin(), nums1.end());
        // for(int i=0; i<nums1.size(); ++i)
        //     record.insert(nums1[i]);

        set<int> res;
        for(int i=0; i<nums2.size(); ++i){
            if(record.find(nums2[i]) != record.end())
                res.insert(nums2[i]);
        }

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

350. 两个数组的交集 II

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        map<int, int> record;
        for(int i=0; i<nums1.size(); ++i){
            if(record.find(nums1[i]) != record.end())
                record[nums1[i]]++;
            else
                record.insert(make_pair(nums1[i], 1));
        }

        vector<int> res;
        for(int i=0; i<nums2.size(); ++i){
            if(record.find(nums2[i]) != record.end() && record[nums2[i]]>0){
                res.push_back(nums2[i]);
                --record[nums2[i]];
            }
        }

        return res;
    }
};

242. 有效的字母异位词

class Solution {
public:
    bool isAnagram(string s, string t) {
        map<char, int> record_s;
        if(s.size()!=t.size())
            return false;
        
        for(int i=0; i<s.size(); ++i){
            if(record_s.find(s[i]) != record_s.end())
                ++record_s[s[i]];
            else
                record_s.insert(make_pair(s[i], 1));
        }

        for(int i=0; i<t.size(); ++i){
            if(record_s.find(t[i]) != record_s.end() && record_s[t[i]]>0){
                --record_s[t[i]];
            }
            else
                return false;
        }

        return true;
    }
};

202. 快乐数

class Solution {
public:
    int pow2Sum(int n){
        int res = 0;
        while(n/10){
            res += pow(n%10, 2);
            n /= 10;
        }

        res += pow(n%10, 2);

        return res;
    }
    bool isHappy(int n) {
        // 重点在于无限循环，当发现循环了以后就停止，返回false
        set<int> record;
        
        while(record.find(n) == record.end()){
            if(n==1)
                return true;
            record.insert(n);
            // 计算下一个n
            n = pow2Sum(n);
        }

        return false;
    }
};

290. 单词规律

class Solution {
public:
    bool wordPattern(string pattern, string s) {
        map<char, string> connect_two_way;
        map<string, char> connect_two_way_r;
        
        // 将s存为数组
        vector<string> vec_s;
        string temp_s;
        for(int i=0; i<s.size(); ++i){
            if(s[i]==' '){
                vec_s.push_back(temp_s);
                ++i;
                temp_s = s[i];
                continue;
            }

            temp_s += s[i];
        }
        vec_s.push_back(temp_s);

        // 大小不一致 肯定false
        if(pattern.size()!=vec_s.size())
            return false;
        // 查看对应关系
        // 正向
        for(int i=0; i<pattern.size(); ++i){
            if(connect_two_way.find(pattern[i]) == connect_two_way.end()){
                connect_two_way.insert(make_pair(pattern[i], vec_s[i]));
            }
            else{
                if(connect_two_way[pattern[i]]!=vec_s[i])
                    return false;
            }
        }
        // 反向
        for(int i=0; i<vec_s.size(); ++i){
            if(connect_two_way_r.find(vec_s[i]) == connect_two_way_r.end()){
                connect_two_way_r.insert(make_pair(vec_s[i], pattern[i]));
            }
            else{
                if(connect_two_way_r[vec_s[i]]!=pattern[i])
                    return false;
            }
        }

        // for(map<char, string>::iterator iter=connect_two_way.begin(); iter!=connect_two_way.end; ++iter){
        //     if()
        // }

        return true;
    }
};

451. 根据字符出现频率排序

class Solution {
public:
    string frequencySort(string s) {
        // 利用pair制作桶，将所有出现的字母及频率放到对应的桶中
        // 针对pair中记录的频率进行排序
        // 按照频率将s重新填满

        pair<int, char> freq[256];
        // 初始化
        for(int i=0; i<256; ++i){
            freq[i].first = 0;
            freq[i].second = i;
        }
        // 记录字母出现的频率
        for(int i=0;i<s.size(); ++i){
            ++freq[s[i]].first;
        }

        // 排序
        sort(freq, freq+256, greater<pair<int, char>>());

        // 重新将s填满
        int index = 0;
        for(int i=0; i<s.size(); ++i){
            while(freq[index].first==0)
                ++index;
            s[i] = freq[index].second;
            --freq[index].first;
        }

        return s;
    }
};