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

一. 哈希表基础

1. 需要使用哈希表的场景?

当遇到需要判断一个元素是否存在与一个集合中的时候,就可以考虑使用哈希表处理

2. 常见的哈希结构

• 数组
• Set 集合
• Map 映射,键值对

3. 哈希碰撞的处理方式?
   4. 拉链法:如果某两个对象的哈希值冲突的话,那么他们在哈希表中将以链表的形式保存并指向同一个哈希值
   5. 线性探测法:如果某两个对象的哈希值冲突那么后一个对象将以此冲突位置为起点向下找空余位置

二. 哈希表相关算法题

242.有效的字母异位词

• 以时间换空间写法：本题中说明只有小写字母可以定义一个长度为26的数组,由a打头字符之间的相对位置即为数组下标;
• 首先遍历字符串s的每一个字符保存每个字符出现的次数做++操作,然后遍历t的字符针对数组中的统计做–操作,遍历完后数组中每一个字符的计数都为零就能确定是异位词

class Solution {
    public boolean isAnagram(String s, String t) {

        //如果出现unicode的话用hash map 替换
//        Map<Character,Integer> sMap = new HashMap();
        //本题中说明只有小写字母
        int[] record = new int[26];
        if (s.length()!=t.length()){
            return false;
        }
        for (int i = 0; i < s.length(); i++) {
            //不需要知道字母在ascII中的具体位置只需要相对下标就行
            record[s.charAt(i)-'a']++;
        }
        for (int i = 0; i < t.length(); i++) {
            //与s的抵消当抵消到每个字符的计数都为0时就能证明时异位词
            record[t.charAt(i)-'a']--;
        }
        for (int i : record) {
            if (i!=0){
                return false;
            }
        }
        return true;

    }
}

349.两个数组的交集

用HashTable缓存,空间换时间

• 时间复杂度:遍历两个数组元素O(m)+O(n) = O(n)
• 空间复杂度:O(n)

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        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();
    }
}

快排+双指针—时间不够后续或则二刷的时候再研究

• 时间复杂度: 排序O(mlogm+nlogn)+双指针寻找元素O(m+n)
• 空间复杂度:排序占用O(logm+logn)

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int length1 = nums1.length, length2 = nums2.length;
        int[] intersection = new int[length1 + length2];
        int index = 0, index1 = 0, index2 = 0;
        while (index1 < length1 && index2 < length2) {
            int num1 = nums1[index1], num2 = nums2[index2];
            if (num1 == num2) {
                // 保证加入元素的唯一性
                if (index == 0 || num1 != intersection[index - 1]) {
                    intersection[index++] = num1;
                }
                index1++;
                index2++;
            } else if (num1 < num2) {
                index1++;
            } else {
                index2++;
            }
        }
        return Arrays.copyOfRange(intersection, 0, index);
    }
}

202.快乐数

1. 此题中明确有可能会出现无限循环的情况，所以考虑通过哈希表缓存平方和如果平方和重复出现那么就不是快乐数推出循环
2. 如果没有出现位平方和重复的情况下就一直找直到平方和等于1
3. 另外关于位运算的操作逻辑：模除10得到最低位，整除10得到去除最低位剩余的高位

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> sums = new HashSet<>(); //保存每次的位平方和
        int sum = 0;
        while (true) {
            while (n!=0){  //这个循环就是计算每一轮的位平方和
                sum += (n%10)*(n%10);
                n = n/10;
            }
            if (sum == 1){
                return true;
            }
            if (sums.contains(sum)){  //如果位平方和重复出现那么就判定出现死循环,返回退出
                return false;
            }
            sums.add(sum); //缓存位平方和
            n = sum;
            sum = 0;
        }
    }
}

1.两数之和

1. 通过哈希表key,value的方式保存数组的值与下标
2. 遍历数组判断taget-nums[i]是否存在与keySet中,如果存在返回,此时需要注意判断key的索引不等于i (6-3=3的情况)

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i],i);
        }
        for (int i = 0; i < nums.length; i++) {
            if (map.containsKey(target-nums[i]) && map.get(target-nums[i]) != i){
                return new int[]{i,map.get(target-nums[i])};
            }
        }

        return null;

    }
}