代码随想录算法训练营第六天|242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和

题目：242.有效的字母异位词

视频：学透哈希表，数组使用有技巧！Leetcode：242.有效的字母异位词_哔哩哔哩_bilibili

题解：

法一：qsort

// int cmp(const void* _a, const void* _b) {

//     char a = *(char*)_a, b = *(char*)_b;

//     return a - b;

// }

// bool isAnagram(char* s, char* t) {

//     int len_s = strlen(s), len_t = strlen(t);

//     if (len_s != len_t) {

//         return false;

//     }

//     qsort(s, len_s, sizeof(char), cmp);

//     qsort(t, len_t, sizeof(char), cmp);

//     return strcmp(s, t) == 0;

// }

法二：哈希表

bool isAnagram(char* s, char* t) {

    int hash[26] = {0};

    int len_s = strlen(s), len_t = strlen(t);

    if(len_s!=len_t)

        return false;

    for(int i = 0; i < len_s; i++){

        hash[s[i]-'a']++;

    }

    for(int i = 0; i < len_t; i++){

        hash[t[i]-'a']--;

    }

    for(int i = 0; i < 26; i++){

        if(hash[i]!=0)

            return false;

    }

    return true;

}

总结：

1、哈希表三种：数组、set、map

        数组主要用于范围小、数量可控的查找范围时

2、何时用哈希：给定一元素，查找该元素是否在集合中出现过

题目：349. 两个数组的交集

视频：学透哈希表，set使用有技巧！Leetcode：349. 两个数组的交集_哔哩哔哩_bilibili

题解：

int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize){

    int hax[1000]={0};//哈希表

    int* a=(int*)malloc(sizeof(int)*1000);

    int j=0;

    int count=0;//记录相同元素的个数

    for(int i=0;i<nums1Size;i++)//将数组1所对应的哈希表全部变为1

    {

        if(hax[nums1[i]]==0)

        {

            hax[nums1[i]]=1;

        }//每个数字只会加一次

    }

    for(int i=0;i<nums2Size;i++)//遍历数组2里所有元素所对应的哈希表，值为1则将该nums2元素放入新数组

    {

        if(hax[nums2[i]]==1)

        {

            a[j]=nums2[i];

            j++;

            count++;

        }

        hax[nums2[i]]--;//防止nums2里面有相同数字

    }

    *returnSize=count;

    return a;

}

 

题目：1.两数之和

视频：梦开始的地方，Leetcode：1.两数之和，学透哈希表，map使用有技巧！_哔哩哔哩_bilibili

题解：

struct hashTable {
    int key;
    int val;
    UT_hash_handle hh;
};

struct hashTable* hashtable;

struct hashTable* find(int ikey) {
    struct hashTable* tmp;
    HASH_FIND_INT(hashtable, &ikey, tmp);
    return tmp;
}

void insert(int ikey, int ival) {
    struct hashTable* it = find(ikey);
    if (it == NULL) {
        struct hashTable* tmp = malloc(sizeof(struct hashTable));
        tmp->key = ikey, tmp->val = ival;
        HASH_ADD_INT(hashtable, key, tmp);
    } else {
        it->val = ival;
    }
}

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    hashtable = NULL;
    for (int i = 0; i < numsSize; i++) {
        struct hashTable* it = find(target - nums[i]);
        if (it != NULL) {
            int* ret = malloc(sizeof(int) * 2);
            ret[0] = it->val, ret[1] = i;
            *returnSize = 2;
            return ret;
        }
        insert(nums[i], i);
    }
    *returnSize = 0;
    return NULL;
}