训练营第六天：242.有效的字母异位词、349.两个数组的交集、202.快乐数 1. 两数之和

本文链接：https://blog.csdn.net/lsp_dd/article/details/127056882

242.有效的字母异位词

熟悉中有着陌生感：悲哀。。。

出错的地方：

在哈希数组中 hash[s[i] - '0'] 这里不是要减去0 而是hash[s[i] - 'a'].这样才能得到正确hash表。此外在最后循环检查的时候要注意使用的是 26 不是两个字符串的任一个长度。还要注意，你检查的是hash表不是两个字符串！！！
就这样，很简单一道题，犯了很多错误。

贴上代码：


bool isAnagram(char *s, char* t) {
    int wordNum[26] = {0};
    memset(wordNum, 0, sizeof(wordNum));
    int sLen = strlen(s);
    int tLen = strlen(t);
    for (int i = 0; i < sLen; i++) {
        wordNum[s[i] - 'a']++;
    }
    for (int i = 0; i < tLen; i++){
        wordNum[t[i] - 'a']--;
    }
    int len = fmax(sLen, tLen);
    for (int i = 0; i < 26; i++) {
        if (wordNum[i] != 0) {
            return false;
        }
    }
    return true;
}

349.两个数组的交集
- 其实一开始没有想到怎么具体解题，看到卡哥介绍后，知道在数据较少的情况下可以直接用数组作为哈希表。也就有了思路，写出了下面的代码：

int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    int num[1001] = {0};
    int size = fmin(nums1Size, nums2Size);
    int* result = (int*)malloc(sizeof(int) * size);
    int top = 0;
    for (int i = 0; i < nums1Size; i++) {
        num[nums1[i]]++;
    }
    for (int i = 0; i < nums2Size; i++) {
        if (num[nums2[i]] > 0){
            result[top++] = nums2[i];
            num[nums2[i]] = 0;
        } 
    }
    *returnSize = top;
    return result;

代码很简单，但是有一个点可能不是很好想到，就是有重复元素怎么办呢？这里就要走每次加入后哈希表设置为0 完美的规避了重复加入的问题。

额，下面就要用哈希了，其实我现在内心很惆怅，因为c语言里的哈希得自己做好多事，又不好记忆，所以在思考直接用c++ 还是自己造轮子。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; 
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for (int a : nums2) {
            if (nums_set.find(a) != nums_set.end()) {
                result_set.insert(a);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

202.快乐数

来到了最难的地方了：用c语言造轮子。
先分析一下题目：题目说了这个过程要么是变为1，要么无限循环但是始终变不到1.所以我们就使用哈希表，来存储我们每次操作过后的数字，操作后的的得到的东西在哈希表里找一下，如果找到，那么说明出现了循环，我们就要跳出 return false。当然了如果最后变成了 1，那么就说明我们成功了。
先来看看c语言中哈希的创建， (当然他只是一个结构，可能下面那个东西起了决定性作用，先不管他，我们先用着，就像我们不知到 #include<stdio.h>是什么意思一个道理。

struct HashTale {
    int key;
    UT_hash_handle hh;
}

接下来在函数中，我们要首先建立一个hash表：
```
struct HashTable *hash  = NULL；
```

接着建立节点，放入hash表中。

struct HashTable *first = (struct HashTable*)malloc(sizeof(struct HashTable);
first->key = n;

接下来是哈希表的一些操作

HASh_ADD_INT(hash, key, first);
//一目了然 这是在向哈希表中添加值


//如果想要再哈希表中寻找某个值是否在其中，我们就要先建立一个指针
struct HashTable *s = NULL;
HASH_FIND_INT(hash, &n, s);
// 注意寻早存在与否 要去其地址

整段的代码如下：

struct HashTable{
    int key;
    UT_hash_handle hh;
}
bool isHappy(int n){
    struct HashTable *hash = NULL;
    int sum;
    struct HashTable *first = (struct HashTable)malloc(sizeof(struct HashTable));
    first->key = n;
    HASH_ADD_INT(hash, key, first);
    while (1) {
        if (n == 1) {
            return true;
        }
        sum = 0;
        while (n > 0) {
            sum += (n%10) * (n%10);
        }
        n = sum;
        struct HashTable* s = NULL;
        HASH_FIND_INT(hash, &n, s);
        if (s) {
            break;
        }
        else {
            s = (struct HashTable)malloc(sizeof(struct HashTable));
            s->key = n;
            HASH_ADD_INT(hash, key, s);
        }
    }
    return false;
}

同样我们附上了c++的代码大家对比一下，就会发现c++是多么成熟的语言

class Solution {
public:
    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> set;
        while(1) {
            int sum = getSum(n);
            if (sum == 1) return true;
            
            if (set.find(sum) != set.end()) {
                return false;
            }
            else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

哈希表三种形式: 数组 set， map

数组适合数据连续且数量较小

set

map：一个key value的结构

总结一下；当我们遇到要快速判断一个元素是否出现在一个集合里的时候我们就要考虑哈希法了

1.两数之和

你以为就是 a+b吗？微笑：呵呵力扣第一题就是劝退题，满心欢喜的点开，准备大展身手，结果半天ac不了，再看题解，是什么哈希表？??什么东东》》
正题：这道题用的是map类的哈希表，key value的结构这里注意添加的操作，赋值的时候，key与value都要赋值，但是ADD的时候只需要加入key就可以

    s->key = target - nums[i];
    s->value = i;
    HASH_ADD_INT(hash, key, s);

struct HashTable{
    int key;
    int value;
    UT_hash_handle hh;
};
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int* result = (int*)malloc(sizeof(int) * 2);
    *returnSize = 2;
    //创建
    struct HashTable *hash = NULL;
     struct HashTable *first = (struct HashTable*)malloc(sizeof(struct HashTable));
     
    for (int i = 0; i < numsSize; i++) {
        struct HashTable *s = NULL;
        HASH_FIND_INT(hash, &nums[i], s);
        if (s) {
            result[0] = s->value;
            result[1] = i;
            return result;
        }
        else {
            s = (struct HashTable*)malloc(sizeof(struct HashTable));
            s->key = target - nums[i];
            s->value = i;
            HASH_ADD_INT(hash, key, s);
        }
    }
    return result;
}

其实一开始数组第一个元素在for外面或者里面加都可以，不影响。
还有就是这个s的操作。在for中，我们先给了他一个空间，但是我们又在哈希表中寻找他，就把他变成了一个指针（这段话是我自己的理解，应该是这样的。）那么指针在else里就不能有赋值的那些操作，必须先给他分配空间。所以我们代码里的形式是对的。

其实这道题可以不同哈希。但这也只是适用于数据量小的时候

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int* result = (int*)calloc(2,sizeof(int));
    *returnSize = 2;
    for (int i = 0; i < numsSize - 1; i++) {
        for (int j = i + 1; j < numsSize ; j++) {
            if(nums[i] + nums[j] == target) {
                result[0] = i;
                result[1] = j;
                return  result;
            }
        }
    }
    return result ;
}

哈希表了解了一个大概，又复习了一遍c语言的哈希。两数之和还没有用c++写。有时间再看。今天学了四个小时++吧

加油！