算法60天训练–9-11-day6

242.有效字母的异位词

思路

暴力解法

简单的两层for循环,同时记录字符是否重复出现,很明显时间复杂度是$O(n^2)$

双指针

需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。

再遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。

复杂度

• 时间复杂度: O(n)
• 空间复杂度: O(1)

Code

class Solution {
    public boolean isAnagram(String s, String t) {
      int[] record = new int[26];
      for(int i = 0; i<s.length(); i++){
        record[s.charAt(i) - 'a']++;
      }

      for(int i = 0; i < t.length(); i++){
        record[t.charAt(i)-'a']--;
      }
      for(int i = 0; i < 26; i++){
        if(record[i] != 0){
          return false;
        }
      }
      return true;
    } 
    }

349. 两个数组的交集

思路

因为是找 交集, 所以可以先去重:

• 先将nums1放在Set容器中,(不包含重复元素)
• 然后遍历nums2元素,查看Set容器中是否包含nums2元素
• 如果包括:就放在另一个resSet集合中

复杂度

• 时间复杂度: O(mn)
• 空间复杂度: O(n)

Code

Java

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {

        if(nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0){
            return new int[0];
        }
        Set<Integer> set1 = new HashSet<>();

        Set<Integer> set2 = new HashSet<>();

        for(int i: nums1){
            set1.add(i);
        }

        for(int i: nums2){
            if(set1.contains(i))
            set2.add(i);
        }

        // return set2.stream().mapToInt(x->x).toArray();

        //方法二: 再申请一个数组

        int[] arr = new int[set2.size()];
        int j = 0;

        for(int i:set2){
            arr[j++] = i;
        }
        return arr;
    }
}

C++

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> resSet;
        unordered_set<int> numsSet(nums1.begin(), nums1.end());

        for(int  i: nums2){
            if(numsSet.find(i) != numsSet.end()){
                resSet.insert(i);
            }
        }
        return vector<int>(resSet.begin(),resSet.end()); //强制转化为数组
    }
};

202. 快乐数

思路

题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。

所以可以考虑哈希法

• 第一步: 首先可以定义一个set存放数据,避免重复.

• 第二步: 然后再while(true)中无限循环,先求出一个数各单数平方的和相加

• 第三步:如果这个数为1, 直接返回true

• 第四步:否则继续向下判断:在set中是否出现过,如果出现过,说明这个数永远不能到1, 即不是一个快乐数. 如果没出现过,那么就将这个和

复杂度

• 时间复杂度: O(logn)
• 空间复杂度: O(logn)

Code

Java

class Solution {

    public int getSum(int n){
        int sum = 0;
        while(n != 0){
            sum += (n%10)*(n%10);
            n = n/10;
       
        }
        return sum;
    }
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        while(true){
            int sum = getSum(n);
            if(sum == 1){
                return true;
            }
            if(set.contains(sum))
            {
                return false;
            } else set.add(sum);
            n = sum;
        }
    
    }
}

C+=

class Solution {
public:
 int getSum(int n){
            int sum = 0;
            while(n){
                sum+=(n%10)*(n%10);
                n/=10;
            }
            return sum;
        }
    bool isHappy(int n) {
    unordered_set<int> set;
    while(1){
        int sum = getSum(n);
        if(sum == 1){
            return true;
        }

        if(set.find(sum) != set.end()){
            return false;
        }else{
            set.insert(sum);
        }
        n = sum;
     }
    }
};

1. 两数之和

思路

再回想一下为什么使用哈希法?

当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

因为本题，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。

选用map来存储key value,为了寻找两个数,将数的值作为key 数的下标作为value

复杂度

• 时间复杂度: O(n)
• 空间复杂度: O(n)

Code

C++

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map<int,int> map;
        for(int i = 0; i < nums.size(); i++){
            auto iter = map.find(target - nums[i]);
            // 看是否与target匹配的ket
            if(iter != map.end()){
                return {iter->second,i};
            }
            //如果没找到匹配对,就把访问过的下标加入到map中
            map.insert(pair<int,int>(nums[i],i));
        }
        return {};
    }
};

Java

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] res = new int[2];

        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            if(map.containsKey(target - nums[i])){
                res[0] = i;
                res[1] = map.get(target-nums[i]);
                break;
            }
            map.put(nums[i],i);
        }
        return res;
    }
}