代码随想录 第二天 242.有效的字母异位词 349.两个数组的交集 202.快乐数 1.两数之和

哈希表解决的问题：快速查找元素是否在一个集合里。

哈希表的结构有三类：

               数组，set，map

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1: 输入: s = "anagram", t = "nagaram" 输出: true

示例 2: 输入: s = "rat", t = "car" 输出: false

对于字符串而言，数组是最容易想到的简单哈希表，那对于字母而言，在计算机内，和它唯一一一对应的，便是ASCII码，可以计算出s内的字母对应的ASCII码和a字母对应的ASCII码之差，然后相加，然后再逐个减掉t内的字母与a之间的ASCII码之间的差值之和，如果结果出现0,则说明是异味词，反之，则说明某个字符串有多余的字母。

代码如下：

class Solution {
public:
    bool ValidAlphabateWord(std::string s1, std::string s2) {
        int record[26] = { 0 };
        for (int i = 0; i <= s1.size(); i++) {
            record[s1[i] - 'a']++;
        }
        for (int i = 0; i <= s2.size(); i++) {
            record[s2[i] - 'a']--;
        }
        for (int i = 0; i <= s2.size(); i++) {
            if (record[i] == 0) {
                return 1;
            }
            else {
                return 0;
            }
        }

    }
};

时间复杂度O(n)

349.两个数组的交集

题意：给定两个数组，编写一个函数来计算它们的交集。

核心思想：先把第一个数组映射为哈希表，然后用第二个数组去遍历哈希表。如果出现相等的元素，则将结果输出到result.

代码如下：

class Solution {
public:
    unordered_set<int>result(vector<int>num1, vector<int>num2) {

        unordered_set<int> myset1(num1.begin(), num1.end());//将num1处理为哈希表
        unordered_set<int> result;//存放结果
        for (auto val:num2) {
         
            if(myset1.find(val)!=myset1.end()){
                result.insert(val);
             
            }
        }
        return unordered_set<int>(result.begin(),result.end());
    }
};

时间负责度O(n)

202.快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为  1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

这个题目的关键点在于，无限循环，这个如何找到，如果，在求它每个位置上的数字的平方和得时候，如果在这之前就得到了相同的和，且不等于1，则代表不是快乐数了，返回false，反之，返回true.

代码如下：

class Solution{
public:
    int GetSum(int n) {
        int sum=0;
        while (n) {
            sum += (n % 10) * (n % 10);
            n = n / 10;
        }
        return sum;
    }
    bool isHappyNumber(int n) {
       unordered_map<int, int>map;
       while (n) {
           int S = GetSum(n);
           int i = 0;
           if (S == 1) {
               return true;
               break;
           }
           unordered_map<int, int>::iterator it;
           it = map.find(S);
           if (it != map.end()&&it->first!=1){
               return false;
               break;
           }
           map.insert({ S,i });
           i++;  
           n = S;
       }
    }
};

时间复杂度：O(n)

1.两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

核心思想：

Step0:   遍历第一个元素，并存到map中。

Step1：继续遍历获得后续数组元素，如果在之前预存数组元素map中，可以找到与之相加之和为target的元素，则返回这两个元素的下标。

Step2:  如果没有找到，就预存到map中,重复Step1.

代码如下：

class Solution {
public:
    int TwoSum(vector<int>nums,int target) {
        unordered_map<int, int>map;
        for (int i = 0; i < nums.size(); i++) {
            int s = target - nums[i];
            unordered_map<int,int>::iterator it;
            it = map.find(s);
            if (it != map.end()) {
              // cout << "[" << it->second << "," << i << "]" << endl;   //输出it对应的元素下标号和符合条件的i
              return  it->second,i ;//使用迭代器(it)遍历 map 中的元素时，it->first 表示当前元素的值（键），it->second 表示当前元素的下标号。可以通过这两个成员函数来获取元素的键值对。而使用下标操作符 [] 可以根据给定的键来访问对应的值，相当于语句 *(m.find(key))。当键不存在时，会自动插入一个键为给定值的键值对，值为空值。
            }
            map.insert({ nums[i], i });   //将遍历过的元素储存在map里,注意map.insert(nums[i], i );会报错：非法的间接寻址，大白话，就是map储存{Key，Value}的值，如果上传一个Key,Value那就是错误的 
        }
    }
};

时间复杂度：O(n)