代码随想录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

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 intersection(vector& nums1, vector& nums2) {
        unordered_set ans;//能直接去重
        unordered_set myset(nums1.begin(), nums1.end());
        for(int num:nums2){
            if(myset.find(num)!=myset.end()){
                ans.insert(num);
            }
        }
        return vector(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

第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 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

2.用map进行哈希映射

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

class Solution {
public:
    vector twoSum(vector& nums, int target) {
        unordered_map  map;
        for(int i=0; isecond,i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair(nums[i],i)); 
        }
        return {};
    }
};