代码随想录day06

242.有效的字母异位词

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

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

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

说明: 你可以假设字符串只包含小写字母。

哈希表法：以空间换时间

        解题：此题实际上就是判断来个字符串是否由相同的字母组成，且字母的顺序不限制。

        具体实现：由于小写字母的ascll码为连续的，因此只需要用一个大小为26的数组进行记录s与t中的字母的个数，进行相反的操作，最后数组中的元素应全为0。

bool isAnagram(char* s, char* t) {
    int isflag[26]={0};
    int l1=strlen(s),l2=strlen(t);
    if(l1!=l2) return false;
    for(int i=0;i<l1;++i){
        isflag[s[i]-'a']++;
    }
    for(int i=0;i<l2;++i){
        isflag[t[i]-'a']--;
    }
    for(int i=0;i<26;++i){
        if(isflag[i]!=0){
            return false;
        }
    }
    return true;
}

349. 两个数组的交集

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

示例1：

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

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

1.用数组做哈希表 

        由于数字在0到1000之间，故可以用一个长1000(可以大一点)的数组进行统计，比较耗费空间，但是效率还是较高的。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> ans;//能直接去重
        unordered_set<int> myset(nums1.begin(), nums1.end());
        for(int num:nums2){
            if(myset.find(num)!=myset.end()){
                ans.insert(num);
            }
        }
        return vector<int>(ans.begin(),ans.end());
    }
};

2.用unordered_set进行哈希映射

        set和multiset底层实现都是红黑树，unordered_set的底层实现是哈希表， 因此，使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    int isexist[1002]={0};
    int* intersection=malloc(sizeof(int)*(nums1Size+nums2Size));
    for(int i=0;i<nums1Size;++i){
        isexist[nums1[i]]=1;
    }
    int k=0;
    for(int i=0;i<nums2Size;++i){
        if(isexist[nums2[i]]==1){
            intersection[k++]=nums2[i];
            isexist[nums2[i]]=0;//记录后要去重
        }
    }
    *returnSize=k;
    return intersection;
}

第202题. 快乐数

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

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

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

1.哈希表检测是否发生循环

        最简单的想法就是模拟，每次就算出每个位置上的数字的平方和,然后会由两种情况：

（1）该数是快乐数，因此当n==1时就会跳出循环，然后返回true

（2）该数不是快乐数，因此在while循环中必然会出现重复的数字，因此可以用哈希表来检测n的值是否发生了重复。

class Solution {
public:
    int fun(int n){
        int sum=0;
        while(n){
            int temp=n%10;
            sum+=temp*temp;
            n=n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
        int key=n;
        unordered_set<int> myset;
        while(n!=1){
           n=fun(n);
           if(myset.find(n)!=myset.end()) return false;//发生了循环
           myset.insert(n);
        }
        return true;
    }
};

2.快慢指针

        由于此题涉及循环的判断，可以联系判断链表是否有环的那那一题。使用快慢指针来判断是否发生了循环。

class Solution {
public:
    int fun(int n){
        int sum=0;
        while(n){
            int temp=n%10;
            sum+=temp*temp;
            n=n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
        int slow=n;
        int fast=fun(n);
        while(fast!=1&&slow!=fast){
            slow=fun(slow);//慢指针走一步
            fast=fun(fun(fast));//快指针走两步
        }
        return fast==1;//最后判断是否为1
    }
};

 1. 两数之和

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

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

示例:

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

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

返回[0,1]

 1.暴力解法

        用两个for循环遍历即可。

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

2.用map进行哈希映射

        由于返回值是下标，因此需要通map进行存下标+值。要注意map的用法。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map <int,int> map;
        for(int i=0; i<nums.size();i++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            auto iter=map.find(target-nums[i]); 
            if(iter!=map.end()) {
                return {iter->second,i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i],i)); 
        }
        return {};
    }
};