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

242.有效字母异位词

1.C++数组哈希表实现，小写英文字母一共就26个。创建两个大小为26的数组分别记录两个字符串每个字母出现的次数，比较两个数组就能知道两个字符串每个字母出现次数是否相等。

class Solution {
public:
    bool isAnagram(string s, string t) {
          vector<int> nums1(26,0);//创建两个数组，分别用来保存两个字符串中每个字母出现的次数
          vector<int> nums2(26,0);
          for(int i=0;i<s.size();i++)//记录字符串s中每个字母出现的次数
          nums1[s[i]-'a']++;
          for(int i=0;i<t.size();i++)//记录字符串t中每个字母出现的次数
          nums2[t[i]-'a']++;
          for(int i=0;i<26;i++){
              if(nums1[i]!=nums2[i])//出现次数不相等，则不是异位词，返回false
              return false;
              else
              continue;
          }
          return true;//出现次数全部相等，是异位词，返回true
    }
};

2.C语言实现，思想大致相同，采用数组哈希表记录字符串中每个字母出现的次数。

bool isAnagram(char* s, char* t) {
    int record[26]={0};//创建一个record数组记录每个字母的次数
    int len_s=strlen(s), len_t=strlen(t);
    for(int i=0;i<len_s;i++)//字符串s中每个字母出现一次对应数组值就+1
    record[s[i]-'a']++;
    for(int i=0;i<len_t;i++)//字符串t中每个字母出现一次对应数组值就-1
    record[t[i]-'a']--;
    for(int i=0;i<26;i++){
        if(record[i]!=0)//记录数组中有不为0的数组值，说明不是异位词
        return false;
    }
    return true;//两个字符串每个字母出现次数都相等
}

349.两个数组的交集

1.测试用例在1000以内，可以用C语言数组哈希表实现。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    int record1[1001]={0};//测试用例在0到1000之内可以用哈希表
    int record2[1001]={0};
    for(int i=0;i<nums1Size;i++)//数组1记录nums1每个数出现的次数
    record1[nums1[i]]++;
    for(int i=0;i<nums2Size;i++)//数组2记录nums2每个数出现的次数
    record2[nums2[i]]++;
    int count=0;
     for(int i=0;i<1001;i++){//用count统计nums1和nums2出现的公共数字
        if(record1[i]!=0&&record2[i]!=0)
        count++;
    }
    *returnSize=count;//count就是返回数组的大小
    int* result=(int*)malloc(sizeof(int)*count);
    int j=0;
    for(int i=0;i<1001;i++){//开始不知道返回数组大小只能重新遍历一遍给返回数组赋值
        if(record1[i]!=0&&record2[i]!=0){
            result[j]=i;
            j++;
        }
    }
    return result;
}

2.C++的set类数据结构适用范围更广

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    unordered_set<int> result;//定义一个int型的unordered_set数据结构接收返回值
    unordered_set<int> nums(nums1.begin(),nums1.end());//创建nums1的unordered_set型哈希表
    for(int num :nums2){//遍历nums2数组，若其值在nums1中出现过则加入result
        if(nums.find(num)!=nums.end())
        result.insert(num);
    }
    return vector<int>(result.begin(),result.end());//将result转换为数组并返回
    }
};

202.快乐数

1.目标值不大可以用C语言数组哈希表实现，核心是判断循环。

bool isHappy(int n) {
    int hash[1000]={0};//由数学方法可知n的每位数的平方和不会超过1000……
    int sum=get_sum(n);
    while(sum!=1){
        if(hash[sum]!=1){//判断sum是否循环
            hash[sum]=1;
        }
        else{
            return false;
        }
        sum=get_sum(sum);
    }
    return true;
}
int get_sum(int n){//n的每位数的平方和的计算函数
    int sum=0;
    while(n){
        sum+=pow(n%10,2);//pow是次方计算函数
        n=n/10;
    }
    return sum;
}

2.C++unordered_set实现。

class Solution {
public:
int get_sum(int n){//n的每位数的平方和的计算函数
    int sum=0;
    while(n){
        sum+=(n%10)*(n%10);
        n=n/10;
    }
    return sum;
}
    bool isHappy(int n) {
        unordered_set<int> set;//创建一个哈希函数，不关心内部实现
        while(1){
            int sum=get_sum(n);
            if(sum==1)   return true;
            if(set.find(sum)!=set.end())//判断sum有没有在哈希函数set中出现过
            return false;//出现返回false
            else
            set.insert(sum);//没出现就把新的sum插入哈希函数set中等待下一轮判断
            n=sum;
        }
    }
};

3.快慢双指针法，注意循环为什么用do……while。

class Solution {
public:
int get_sum(int n){//n的每位数的平方和的计算函数
    int sum=0;
    while(n){
        sum+=(n%10)*(n%10);
        n=n/10;
    }
    return sum;
}
    bool isHappy(int n) {//快慢双指针法
        int slow=n,fast=n;
        do{//do……while循环条件不成立也会执行一次，如果用while循环就直接退出了
            slow = get_sum(slow);//慢指针每次走一步，快指针每次走两步
            fast = get_sum(fast);
            fast = get_sum(fast);
        }while(slow!=fast);
        return (slow==1);//跳出循环时slow==fast，这时候二者如果不等于1说明一会还要循环，不是快乐数
    }
};

1.两数之和

1.C语言双重暴力循环

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {//两重for循环遍历
    int i, j;
	for (i = 0; i < numsSize - 1; i++) {
		for (j = i + 1; j < numsSize; j++) {
			if (nums[i] + nums[j] == target) {
				int* ret = malloc(sizeof(int) * 2);
				ret[0] = i;
				ret[1] = j;
				*returnSize = 2;//返回数组大小
				return ret;
			}
		}
	}
	*returnSize = 0;//找不到返回空指针
	return NULL;
}

2.C++unordered_map哈希表实现。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {//创建一个unordered_map类型的哈希表
        unordered_map<int,int> u_map;//用来记录遍历过的元素及对应下标
        for(int i=0;i<nums.size();i++){//遍历数组在哈希表中寻找是否有需要的数
            auto iter=u_map.find(target-nums[i]);
            if(iter!=u_map.end())//找到对应元素
            return {iter->second,i};//first对应元素，second对应下标
            else
            u_map[nums[i]]=i;//没找到就把遍历过的元素及下标加入哈希表
        }
        return {};//没找到就返回空数组
    }
};

今天的题在LeetCode上都属于easy题，但其实并不easy。尤其对于我这样以前没学过C++的人来说，用C语言实现数组哈希表以外的哈希表十分困难。好在昨天休息补了一点C++的哈希表知识，勉强看懂题解听懂视频。

今日总结：路漫漫其修远兮