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

哈希表总结，常见的哈希表结构以及区别

LeetCode 242 有效的字母异位词
题目链接：有效的字母异位词

思路：最直接的思路是用哈希表的结构去储存不同的字母，然后对两个字符串分别遍历，看是否储存的值有变化，自己思考的代码使用hashMap实现的，但不如数组简洁。

package HashTable;

import java.util.HashMap;

/**
 * @author rpstart
 * @create 2023-07-03 20:07
 */
public class isAnagram242 {
    public static void main(String[] args) {
        String s = "anagram";
        String t = "nagarat";
        boolean res = isAnagram(s, t);
        System.out.println(res);
    }
    public static boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        HashMap<Character, Integer> sMap = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            sMap.put(s.charAt(i),sMap.getOrDefault(s.charAt(i),0) + 1);
        }
        for (int i = 0; i < t.length(); i++) {
            sMap.put(t.charAt(i),sMap.getOrDefault(t.charAt(i),0) - 1);
            if ((int)(sMap.get(t.charAt(i))) < 0) {
                return false;
            }
        }
        return true;
    }
}

补充使用数组作为哈希表结构的处理方式。

private static 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 < record.length; i++) {
            if (record[i] != 0) {
                return false;
            }
        }
        return true;
    }

LeetCode 349 两个数组的交集
题目链接：两个数组的交集

思路：题目要求是不需要重复元素，只要把两个数组中相同的数字给出即可，那么很容易就想到Set结构，因为Set结构跟数学中的集合一样，是没有重复元素的。

package HashTable;

import java.util.*;

/**
 * @author rpstart
 * @create 2023-07-03 20:31
 */
public class intersection349 {
    public static void main(String[] args) {
        int[] nums1 = {4,9,5};
        int[] nums2 = {9,4,9,8,4};
        int[] res = intersection(nums1, nums2);
        System.out.println(Arrays.toString(res));
    }
    public static int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> integers = new HashSet<>();
        HashSet<Integer> list = new HashSet<>();
        for (int i = 0; i < nums1.length; i++) {
            if (!integers.contains(nums1[i])){
                integers.add(nums1[i]);
            }
        }

        for (int i = 0; i < nums2.length; i++) {
            if (integers.contains(nums2[i])){
                list.add(nums2[i]);
            }
        }

        int[] res = new int[list.size()];
        int j = 0;
        for (int i : list
             ) {
            res[j++] = i;
        }
        return res;
    }
}

LeetCode 202 快乐数
题目链接：快乐数

思路：通过Set结构对数进行储存，如果再循环过程中出现之前重复出现的数，那么该数一定不可能退出循环。关键的思路在于判断这个循环。

package HashTable;

import java.util.HashSet;

/**
 * @author rpstart
 * @create 2023-07-03 20:52
 */
public class isHappy202 {
    public static void main(String[] args) {
        boolean res = isHappy(19);
        System.out.println(res);
    }

    public static boolean isHappy(int n) {
        HashSet<Integer> set = new HashSet<>();
        while (n != 1 && !set.contains(n)) {
            set.add(n);
            n = getNumber(n);
        }
        return n == 1;
    }

    public static int getNumber(int n) {
        int res = 0;
        while (n != 0 ) {
            int temp = n % 10;
            res += temp * temp;
            n = n / 10;
        }
        return res;
    }
}

LeetCode 1 两数之和
题目链接：两数之和

思路：这道题关键的思路在于想到用哈希结构，为什么用哈希结构。map主要的作用在于储存遍历的值的下标，同时题目要求数组中的元素不能重复出现，也就是说同一个元素自加等于目标值是不行的，在考虑时要考虑这个情况，所以才要一边储存，一边查找两个合适的值。

package HashTable;

import java.util.Arrays;
import java.util.HashMap;

/**
 * @author rpstart
 * @create 2023-07-03 21:33
 */
public class twoSum1 {
    public static void main(String[] args) {
        int[] nums = {2,7,11,15};
        int target = 9;
        int[] res = twoSum(nums, target);
        System.out.println(Arrays.toString(res));
    }

    public static int[] twoSum(int[] nums, int target) {
        int[] res = new int[2];
        if (nums == null || nums.length == 0) {
            return res;
        }
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int temp = target - nums[i];
            if (map.containsKey(temp)) {
                res[1] = i;
                res[0] = map.get(temp);
                return res;
            }
            map.put(nums[i],i);
        }
        return res;
    }
}