Leetcode 刷题之Hash and Tree

滑动窗口

349. Intersection of Two Arrays

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        set<int> rec(nums1.begin(),nums1.end());
        set<int> res;
        for(int idx = 0; idx < nums2.size(); idx++) {
            if(rec.find(nums2[idx]) != rec.end()) {
                res.insert(nums2[idx]);
            }
        }
        return vector<int>(res.begin(), res.end());
    }
};

350. Intersection of Two Arrays II

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        map<int,int>mp1;
        vector<int> res;
        for(int idx = 0; idx < nums1.size(); idx++) {
            mp1[nums1[idx]]++;
        }
        for(int idx = 0; idx < nums2.size(); idx++) {
            if(mp1[nums2[idx]] > 0) {
                res.push_back(nums2[idx]);
                mp1[nums2[idx]]--;
            }
        }
        return res;
    }
};

map的时间复杂度是O(nlogn)，空间复杂度是O(n)，底层实现是二叉平衡树。
unordered_map的时间复杂度是O(n)，空间复杂度是O(n)，底层实现是哈希表。

242. Valid Anagram

class Solution {
public:
    bool isAnagram(string s, string t) {
        map<char, int> rec;
        for(int idx = 0; idx < s.size(); idx++) {
            rec[s[idx]]++;
        }
        for(int idx = 0; idx < t.size(); idx++) {
            rec[t[idx]]--;
            if(rec[t[idx]] < 0) {
                return false;
            }
        }
        for(map<char,int>::iterator it = rec.begin(); it != rec.end(); it++) {
            if(it->second) {
                return false;
            }
        }
        return true;
    }
};

202. Happy Number

class Solution {
public:
    bool isHappy(int n) {
        set<int> rec;
        while(1) {
            string str = to_string(n);
            int tmp = 0;
            for(char c:str) {
                tmp += (c - '0')*(c - '0');
            }
            if(tmp == 1) {
                return true;
            }
            if(rec.find(tmp) == rec.end()) {
                rec.insert(tmp);
            }
            else {
                return false;
            }
            n = tmp;
        }

        return true;
    }
};

290. Word Pattern

class Solution {
public:
    vector<string> split(string str, string pattern)
    {
        string::size_type pos;
        vector<string> result;
        str += pattern;
        int size=str.size();

        for(int i=0; i<size; i++)
        {
            pos=str.find(pattern,i);
            if(pos<size)
            {
                string s = str.substr(i,pos-i);
                result.push_back(s);
                i = pos+pattern.size()-1;
            }
        }
        return result;
    }

    bool wordPattern(string pattern, string str) {
        map<char, string> rec;
        map<string, char> rec2;
        vector<string> strs = split(str, " ");
        if(strs.size() != pattern.size()) {
            return false;
        }
        for(int idx = 0; idx < pattern.size(); idx++) {
            if(rec.find(pattern[idx]) == rec.end()) {
                rec[pattern[idx]] = strs[idx];
            }
            else {
                if(rec[pattern[idx]].compare(strs[idx])) {
                    return false;
                }
            }
            if(rec2.find(strs[idx]) == rec2.end()) {
                rec2[strs[idx]] = pattern[idx];
            }
            else {
                if(rec2[strs[idx]] != pattern[idx]) {
                    return false;
                }
            }
        }
        return true;
    }
};

205. Isomorphic Strings

class Solution {
public:
    bool isIsomorphic(string s, string t) {
        int s_len = s.size();
        int t_len = t.size();
        if(s_len != t_len) {
            return false;
        }
        map<char, char> rec1;
        map<char, char> rec2;
        for(int idx = 0; idx < s_len; idx++) {
            if(rec1.find(s[idx]) == rec1.end()) {
                rec1[s[idx]] = t[idx];    
            }
            else {
                if(rec1[s[idx]] != t[idx]) {
                    return false;
                }
            }
            if(rec2.find(t[idx]) == rec2.end()) {
                rec2[t[idx]] = s[idx];    
            }
            else {
                if(rec2[t[idx]] != s[idx]) {
                    return false;
                }
            }
        }
        return true;
    }
};

451. Sort Characters By Frequency

class Solution {
public:
    string copy_chars(int cnt, char c) {
        string res;
        for(int idx = 0; idx < cnt; idx++) {
            res += c;
        }
        return res;
    }

    string frequencySort(string s) {
        string res;
        map<char, int> rec;
        for(char c:s) {
            rec[c]++;
        }
        map<int,vector<char>> recs;
        for(map<char, int>::iterator it = rec.begin(); it != rec.end(); it++) {
            if(recs.find(it->second) == recs.end()) {
                vector<char> tmp;
                tmp.push_back(it->first);
                recs.insert(make_pair(it->second, tmp));
            }
            else {
                recs[it->second].push_back(it->first);
            }
        }
        map<int,vector<char>>::reverse_iterator rit;
        for (rit = recs.rbegin(); rit != recs.rend(); ++rit) {
            int count = rit->first;
            vector<char> chars = rit->second;
            for(vector<char>::iterator it = chars.begin(); it != chars.end(); it++) {
                res += copy_chars(count, *it);
            }
        }
        return res;
    }
};

哈希表

454. 4Sum II

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        assert(A.size() == B.size() || B.size() == C.size() || 
               C.size() == D.size() || A.size() <= 500);
        unordered_map<int,int> rec;
        for(int idx1 = 0; idx1 < A.size(); idx1++) {
            for(int idx2 = 0; idx2 < B.size(); idx2++) {
                rec[A[idx1]+B[idx2]]++;
            }
        }
        int res = 0;
        for(int idx1 = 0; idx1 < C.size(); idx1++)