初遇哈希表

对于我来说，刚刚着手代码的新手，在算法方面还是了解比较短浅，很多算法名称也从未听说过。
很多知识都是通过在 leetcode 上做题，看题解了解的，哈希表就是其中的一种。

第一次看到哈希表这个名词还是在 leetcode 上的一道《两数之和》，当时我是在做数组部分的题，在学习题解的时候突然了解到哈希表这个名词，然后就深入了解了一下，然后被哈希表冗长的代码迷惑住了。

第一反应就是这代码怎么这么长！！！QAQ

但是看到哈希表的时间复杂度，确实还是比双重 for 循环要小的多。

最近便到哈希表专题了解了下哈希表的用法。

下面是一些菜鸟代码：

一、《快乐数》

题目要求：

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

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

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

示例：

输入：19
输出：true

解释：

1² + 9² = 82
8² + 2² = 68
6² + 8² = 100
1² + 0² + 0² = 1

bool isHappy(int n){
    int hash[500] = {0};
    int sum;
    while(n != 1)
    {
        sum = 0;
        while(n > 0)
        {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        if(hash[sum] == 0)
        {
            hash[sum] = 1;
            n = sum;
        }
        else
            return false;
    }
    return true;
}

二、《同构字符串》

题目要求：

给定两个字符串 s 和 t，判断它们是否是同构的。

如果 s 中的字符可以被替换得到 t ，那么这两个字符串是同构的。

所有出现的字符都必须用另一个字符替换，同时保留字符的顺序。两个字符不能映射到同一个字符上，但字符可以映射自己本身。

示例 1:

输入: s = “egg”, t = “add”
输出: true

示例 2:

输入: s = “foo”, t = “bar”
输出: false

示例 3:

输入: s = “paper”, t = “title”
输出: true

bool isIsomorphic(char * s, char * t){
    int hash1[128] = {0}, hash2[130] = {0}, len = strlen(s);
    for (int i = 0; i < len; i++) {
        if ((hash1[s[i]] == 0 && hash2[t[i] + 0] != 0) || (hash1[s[i]] > 0 && hash1[s[i]] != t[i] + 0))
            return false;
        else if(hash1[s[i]] == 0)
        {
            hash1[s[i]] = t[i] + 0;
            hash2[t[i] + 0] = 1;
        }
    }        
    return true;
}

当然，在学习过程中也发现了哈希表的问题，目前我接触了哈希表数组，对于字符串的时候，由于ASNII 编码只需要 128 位，所以建立数组比较方便，但是在处理 int 型数组的时候，负数和大数据成为了哈希表数组的问题，这就需要进一步的深入的学习更深层次的哈希表了。

下面就是数组的问题代码：

错误代码一：《两个数组的交集 II》

题目要求：

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

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]

说明：

1.输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
2.我们可以不考虑输出结果的顺序。

int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){
    int i, k = 0, t1;
    int hash[99999];
    memset(hash, 0, 99999);
    if(nums1Size > nums2Size)
    {
        for(i = 0; i < nums1Size; i++)
        {
            hash[nums1[i]]++;
        }
        for(i = 0; i < nums2Size; i++)
        {
            if(hash[nums2[i]] > 0)
            {
                nums1[k] = nums2[i];
                hash[nums2[i]]--;
                k++; 
            }
        }
        *returnSize = k;
        return nums1;
    }
    else
    {
        for(i = 0; i < nums2Size; i++)
        {
            hash[nums2[i]]++;
        }
        for(i = 0; i < nums1Size; i++)
        {
            if(hash[nums1[i]] > 0)
            {
                nums2[k] = nums1[i];
                hash[nums1[i]]--;
                k++; 
            }
        }
        *returnSize = k;
        return nums2;
    }
}

错误代码二：《存在重复元素 II》

题目要求：

给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。

示例 1:

输入: nums = [1,2,3,1], k = 3
输出: true

示例 2:

输入: nums = [1,0,1,1], k = 1
输出: true

示例 3:

输入: nums = [1,2,3,1,2,3], k = 2
输出: false

bool containsNearbyDuplicate(int* nums, int numsSize, int k){
    int hash[1000];
    memset(hash, 0, 1000);
    int i, min = k + 1, b = 0;
    for(i = 0; i < numsSize; i++)
    {
        if(b == 0 && nums[i] == nums[0] && i > 0)
        {
            if(min > i - hash[nums[0]])
            {
                min = i - hash[nums[0]];
            }
            b++;
        }
        else if(hash[nums[i]] != 0)
        {
            if(min > i - hash[nums[i]])
            {
                min = i - hash[nums[i]];
            }
        }  
        hash[nums[i]] = i;    
    }
    if(k < min)
    {
        return false;
    }
    return true;
}