算法训练Day6

2023年3月6日

今天的任务有五个

#哈希表理论基础

理论基础不再介绍，详情链接为 (2条消息) 字典初步认识_RookieZHL的博客-CSDN博客

#有效的字母异位词 242. 有效的字母异位词 - 力扣（LeetCode）

这道题的暴力算法就是固定str1的一个字符，然后在str2中逐个寻找，通过记录该字符在str1中和str2中出现的次数进行比较，若出现的字母以及相应的次数都一样，则可以说明两个字符串是有效的字母异位词。由于吃力不讨好，所以无代码。

第二种方法就是利用STL中给好的成员函数方法，通过将两个字符串进行排序，然后逐位比较，若一一对应，则说明两个字符串是有效的字母异位词，代码如下

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.length() != t.length()) {
            return false;
        }
        sort(s.begin(), s.end());
        sort(t.begin(), t.end());
        return s == t;
    }
};

第三种方法跟第二种方法大差不差，通过将两个string转换为set，然后比较两个set，代码如下：

class Solution {
public:
    bool isAnagram(string s, string t) {
        multiset<int>str1;
        multiset<int>str2;
        for(int i=0;i<s.length();i++)
        {
            str1.insert(s[i]-65);
        }
        for(int i=0;i<t.length();i++)
        {
            str2.insert(t[i]-65);
        }
        if(str1==str2) return true;
        return false;
    }
};

第四种方法就是按照代码随想录中的方法，设置一个26长度的全0数组充当哈希表的功能，每个a[i]存储字符串1中字母出现的次数，然后再将一维数组与字符串2进行比较，若相同，则将出现的次数-1，若不同则继续+1，如果最终这个一维数组是全0的，那么就可以说明两个字符串是有效的字母异位词。代码如下：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for (int i = 0; i < s.size(); i++) {
            // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            record[s[i] - 'a']++;
        }
        for (int i = 0; i < t.size(); i++) {
            record[t[i] - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
            if (record[i] != 0) {
                // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        // record数组所有元素都为零0，说明字符串s和t是字母异位词
        return true;
    }
};

这道题的思想可以说明哈希表的作用原理与应用范围，哈希表的本质就是为了方便索引的，如果还不太懂的话建议重新复习一下。

#两个数组的交集

这道题可以说一眼set，求两个数组的交集说白了就是看两个数组有哪些重复的元素，直接把数组变set，然后变完后的set与数组进行比较，如果数组中有而set中没有的话，就不用管，如果数组中有set中也有，就添加到答案数组中，这里简单提一下find 的作用：find算法用于在迭代器定义的前闭后开区间[first,last)所形成的搜索范围中找到第一个与val值“相等”的元素，并返回元素位置；若没有找到，则返回last，本题代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for (int num : nums2) {
            // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

为什么最后要返回vector呢，答案显而易见了，耗时啊，若用set的话每个元素都要进行一次hash计算，在数据量大的时候会非常耗时。

#快乐数

第一次想的是不断的求sum，直至sum=1为止，但是后来说会无限循环，就想设置一个值保存sum上一次的值，当本次的值与上次的值相同的时候退出循环，后来发现理解错了，不一定是一个数一直循环，有可能是一堆数轮流循环，难道要设置一个很长的数组吗？

当然不是，这时候就需要设置一个set，当sum的值能在set中找到的时候，说明进入死循环了，这时候退出循环能减少时间消耗，思路就是这么一个思路，代码如下：

class Solution {
public:
    // 取数值各个位上的单数之和
    int getSum(int n) {
        int sum = 0;
        while (n) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> set;
        while(1) {
            int sum = getSum(n);
            if (sum == 1) {
                return true;
            }
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            if (set.find(sum) != set.end()) {
                return false;
            } else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

注：其中的getSum函数就是用来计算每位的平方然后相加后的和的函数，当n>0的时候，就一直取n%10，即最后一位，进行相乘，然后n/10进行“右移”，再取最后一位进行相乘，直至原数为0

#两数之和

这是一道经典不能再经典的题了。

首当其冲的，也是最简单的，便是暴力解法，两个for循环，把所有的情况列出来，然后返回

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n = nums.size();
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (nums[i] + nums[j] == target) {
                    return {i, j};
                }
            }
        }
        return {};
    }
};

第二种是运用双指针的思路，先对数组nums进行排序，然后两个指针对应的数进行相加，若大于目标值target，则将右指针左移一位再进行判断，若两个指针对应的数相加后的和小于目标值target，将左指针右移一位进行判断，直至两个指针相遇，判断结束，不过这种方法不可取，因为目标数组nums是无序的，正好印证了前面数组那一章的“使用类似双指针法时需要数组排序”的前提，这里考虑的并不周全，不过这里可以用Python中的numpy模板进行考虑，numpy中有一中方法可以返回排序后的对应下标，由于我主练的是C++，这里就不对Python进行过多说明

第三种就是哈希表法。由于题目中说了一个数字不能重复使用，可以考虑使用map进行转换，为什么不用set呢？因为最终返回的是数组的下标，也就是说下标和数组中的值是一一对应的，所以采用map进行存储，这样返回值的同时能将数组下标进行返回。例如，数组中的第一个数是2，target是9，那么我就在map中寻找key==7的键值对，如果我没找到，那么就把key==2的键值对进行插入，以便其他数对寻找2的时候能更快的进行查找。当我在map中找到相应的键值对的时候，由于map 的特性，我就可以直接返回键值对中的下标，方便了代码的设计，代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map <int,int> map;
        for(int i = 0; i < nums.size(); i++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) {
                return {iter->second, i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};

关于代码中的方法详细用法请参考(3条消息) 字典初步认识_RookieZHL的博客-CSDN博客

今天的代码训练就到此为止，下午对树的内容开一个头吧，希望自己能坚持下去，明天见