代码随想录算法训练营第6天-242.有效的字母异位词-349. 两个数组的交集-202. 快乐数-1. 两数之和

242.有效的字母异位词

普通数组直接哈希

bool isAnagram(string s, string t) {
    //用哈希表处理
    int hash[26];
    memset(hash, 0, 26 * sizeof(int));
    for (auto&c : s) 
    {
        hash[c - 'a']++;
    }

    for (auto&c : t)
    {
        hash[c - 'a']--;
    }

    for (auto& num : hash)
    {
        if (num != 0) return false;
    }

    return true;
}

349. 两个数组的交集

1.不用特殊数据结构

vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    vector<int> res;
    int a[1000];
    memset(a, 0, 1000 * sizeof(int));

    for (int i = 0; i < nums1.size(); i ++)
    {
        if (a[nums1[i]] == 0) a[nums1[i]]++;
    }

    for (int i = 0; i < nums2.size(); i ++)
    {
        if (a[nums2[i]] < 10) a[nums2[i]] += 10;
        // cout << nums2[i] << ' ' << a[nums2[i]] << endl;
    }

    for (int i = 0; i < 1000; i ++)
    {
        if (a[i] >= 11)
            res.push_back(i);
    }

    return res;
}

2.使用unordered_set

vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    unordered_set<int> result;
    unordered_set<int> nums_set(nums1.begin(), nums1.end()); //直接把nums1转化为集合

    for (auto num : nums2)
    {
        if (nums_set.find(num) != nums_set.end())
        {
            result.insert(num);
        }
    }

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

202. 快乐数

用unordered_set

    int getSum(int n)
    {
        int sum = 0;
        while (n > 0)
        {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }



    bool isHappy(int n) {
        unordered_set<int> num_set;

        while (true)
        {
            if (n == 1) return true;
            else if (num_set.find(n) != num_set.end())
            {
                return false;
            }
            else
            {
                num_set.insert(n);
                n = getSum(n);
            }
        }
    }

1. 两数之和

暴力

vector<int> twoSum(vector<int>& nums, int target) {
    vector<int> res;

    for (int i = 0; i < nums.size(); i++)
    {
        for (int j = 0; j < nums.size(); j++)
        {
            if (nums[i] + nums[j] == target && i != j)
            {
                res.push_back(i);
                res.push_back(j);
                return res;
            }
        }
    }

    return res;
}

unordered_map

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())
        {
            return {it->second, i};
        }

        map.insert(pair<int, int>(nums[i], i));
    }
    return {};
}