代码随想录算法训练营第六天|Leetcode242.有效的字母异位词 Leetcode349.两个数组的交集 Leetcode202.快乐数 Leetcode1.两数之和

哈希表基础知识整理

Hash table

哈希表是根据关键码的值而直接进行访问的数据结构

一般哈希表都是用在快速判断一个元素是否在集合里

unordered_set & unordered_map

set代表集合 map代表映射

哈希集合是集合的数据结构的实现之一，用于存储非重复值

哈希映射是映射的数据结构的实现之一，用于存储<key, value>键值对

#include<unordered_set>

int main() {
    // 初始化哈希集合
    unordered_set<int> hashset;
    // 插入一个新元素
    hashset.insert(3);
    hashset.insert(2);
    hashset.insert(1);
    // 删除集合中的一个元素
    hashset.erase(2);
    // 判断一个元素是否在哈希集合里
    if (hashset.count(2) <= 0) {
        cout << " 2 is not in hashset." << endl;
    }
    // 计算哈希集合的元素数量
    cout << hashset.size() << endl;
    // 遍历哈希集合
    for (auto it = hashset.begin(); it != hashset.end(); ++it) {
        cout << *it << " ";
    }
    // 清空哈希集合
    hashset.clear();
    // 判断哈希集合是否为空
    if (hashset.empty()) {
        cout << "hashset is empty!" << endl;
    }
 }

Leetcode242.有效的字母异位词

题目链接

思路：数组本身就是哈希表的最好载体，哈希表的意义在于牺牲空间代价减少算法时间复杂度

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.size() != t.size()) return false;
        int hashset[26] = {0};
        for (int i = 0; i < s.size(); ++i) {
            hashset[s[i] - 'a']++;
        }
        for (int j = 0; j < t.size(); ++j) {
            hashset[t[j] - 'a']--;
        }
        for (int i = 0; i < 26; ++i) {
            if (hashset[i] != 0) return false;
        }
        return true;
    }
};

Leetcode349.两个数组的交集

题目链接

主要是要学习到用迭代器初始化的语法

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        unordered_set<int> nums1_set(nums1.begin(), nums1.end());
        for (auto num : nums2) {
            if (nums1_set.count(num) != 0) {
                result_set.insert(num);
            }
        }
        vector<int> result;
        for (auto it = result_set.begin(); it != result_set.end(); ++it) {
            result.push_back(*it);
        }
        return result;
    }
};

反思：不断熟练哈希集合的一些基础操作，这里没有很强的算法知识

Leetcode202.快乐数

题目链接

class Solution {
public:
    int calculate(int n) {
        int num = 0;
        while (n >= 10) {
            int tmp = n % 10;
            num += tmp * tmp;
            n = n / 10;
        }
        num += n * n;
        return num;
    }
    bool isHappy(int n) {
        unordered_set<int> hashset;
        while (hashset.count(n) <= 0) {
            if (n == 1) return true;
            hashset.insert(n);
            n = calculate(n);
        }
        return false;
    }
};

Leetcode1.两数之和

题目链接

从本题接触哈希映射的运用

哈希映射是用于存储（key, value）键值对的一种数据结构

#include<unordered_map>

int main(){
    //初始化一个哈希映射
    unordered_map<int, int> hashmap;
    //插入一个新的键值对
    hashmap.insert(make_pair(0, 0));
    hashmap.insert(make_pair(2, 3));
    //插入一个新的键值对或者更新现有键的值
    hashmap[1] = 1;
    hashmap[1] = 2;
    //获得特殊键的值
    cout << "The value of key 1 is " << hashmap[1] << endl;
    //删除一个键
    hashmap.erase(2);
    //判断一个键是否在哈希映射内
    if (hashmap.count(2) <= 0) {
        cout << "The key 2 is not in hashmap." << endl;
    }
    //得到哈希映射的元素数量
    cout << hashmap.size() << endl;
    //遍历哈希映射
    for (auto it = hashmap.begin(); it != hashmap.end(); ++it) {
        cout << '(' << it->first << ',' << it->second << ')' << endl;
    }
    //清空哈希映射
    hashmap.clear();
    //判断哈希映射是否为空
    if (hashmap.empty()) 
}

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> hashmap;
        vector<int> result;
        for (int i = 0; i < nums.size(); ++i) {
            if (hashmap.count(target - nums[i]) == 1) {
                auto iter = hashmap.find(target - nums[i]);
                result.push_back(iter->second);
                result.push_back(i);
            }
            else {
                hashmap.insert(make_pair(nums[i], i));
            }
        }
        return result;
    }
};

今日学习时长：2h（毛概课）

开始上课了，开始忙起来了，加油