Day6 | | 242.有效的字母异位词 ,349. 两个数组的交集 , 202. 快乐数 ,1. 两数之和

今天开始哈希表的算法学习

一、哈希表前置知识

哈希表是一个数组和单向链表的结合体。
数组：在查询方面效率很高，随机增删方面效率很低。
单向链表：在随机增删方面效率较高，在查询方面效率很低。
哈希表将以上的两种数据结构融合在一起，充分发挥它们各自的优点。
这篇文章讲得很详细
https://blog.csdn.net/weixin_62838185/article/details/123236650

今日算法

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true
示例 2: 输入: s = “rat”, t = “car” 输出: false
说明: 你可以假设字符串只包含小写字母。

思路：只需要一个一维数组（大小为26 因为有26个英文字母），这个数组用于记录s中，哪些字母出现了多少次。a映射到arr[0] ,z映射到arr[25]。比如apple，只需要遍历s，然后a出现一次，就arr[s.charAt(i) - ‘a’] ++;
遍历完s 就去遍历t，对t中出现的字符映射哈希表索引上的数值再做-1的操作。
最后遍历数组，有元素不为0 直接返回false，全都为0返回true

时间复杂度为O(n)，空间上因为定义是的一个常量大小的辅助数组，所以空间复杂度为O(1)。

 public static boolean isAnagram(String s, String t) {
        int[] arr = new int[26];  //定义一个容量为26的数组 （空间上就是O(1)）
        for (int i = 0; i < s.length(); i++) {
            arr[s.charAt(i) - 'a'] ++;
            //这个映射方式很巧妙 利用ASCll码的相对关系，将a - z 映射到数组对应的下标
            //当然这里是因为全都是小写字母，如果可能有大写字母还要加入
            //s.toLowerCase();
        }
        for (int i = 0; i < t.length(); i++) {
            arr[t.charAt(i) - 'a'] --;
        }
        //最后遍历arr
        for (int i = 0; i < arr.length ; i++) {
            if (arr[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 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000

所以就可以 使用数组来做哈希表了， 因为数组都是 1000以内的。

public static int[] intersection(int[] nums1, int[] nums2) {
        //考虑数组为空的可能
        if(nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0){
            return new int[0];
        }
        //将其中一个数组放进去
        // HashSet<> set1 = new HashSet();  这么写会报错
        HashSet<Integer> set1 = new HashSet<>();
        for (int i = 0; i < nums1.length; i++) {
            set1.add(nums1[i]);
        }
        //遍历数组2 判断哈希表中是否存在该元素 要是存在就放到resSet里面
        //因为有去重的需求
        HashSet<Integer> resSet = new HashSet<>();
        for (int i : nums2) {
            if(set1.contains(i)){
                resSet.add(i);
            }
        }
//        Object[] objects = resSet.toArray();
//        这种从集合转向数组的方式 返回Object类型数组 且不能强制转换
//        for (Object object : objects) {
//            System.out.println(object);
//        }

        /**
         * 这种方法转数组 要求toArray里面放的数组一定是应用类型的
         * int不能 Integer才行
         */
        Integer[] a = new Integer[0];
        Integer[] b = resSet.toArray(a);
        for (Integer integer : b) {
            System.out.println(integer);
        }

        //将结果集合转为数组
        return resSet.stream().mapToInt(x -> x).toArray();
        //return Arrays.stream(b).mapToInt(Integer::valueOf).toArray();
    }

第202题. 快乐数

题目：
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果 可以变为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。
示例：
输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1
思路
题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！
当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。
所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。
另外在求每一位数的平方和的时候 不需要把每一位数单独放出来 再一位一位求平方。完全可以%10 拿到当前个位数 sum += sum 然后 /10

public static boolean isHappy(int n) {
        if(n == 1){
            return true;
        }
        HashSet<Integer> set = new HashSet<>();
        //这里是有个循环在的 要考虑出循环的条件
        while (n != 1 && !set.contains(n)){
            set.add(n);
            n = getNext(n);
        }
        //出来的结果无非是 n == 1 或者 n != 1 但是在集合中重复了
        return n == 1;
    }
    public static int getNext(int n){
        int sum = 0;
        while (n != 0){
            int temp = n % 10;
            sum += temp * temp;
            n = n/10;
        }
        return sum;
    }

1. 两数之和

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

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

示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

首先再次强调！！！
什么时候使用哈希法，当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

思路
1、为什么会想到用哈希表
核心：查找集合中该元素是否存在
把遍历到的，不重复的元素放进哈希表，然后在遍历的过程中找这张表里有没有能够满足条件的元素
比如 nums = [2, 7, 11, 15]
nums[0] 查找set 没有元素可以 + nums[0] = 9
同时集合里也没有2 那么添加
遍历到 nums[1] 集合里有2 2+7 = 9 这就找到了
因为题干里说每种输入只对应一个答案
1、1为什么不采用两次for循环 第一次把所有元素放进哈希表 第二次去找对应的满足条件的元素
首先 计算哈希值比较费时间
其次 题干中要求一个元素不可以使用两次
两次遍历的话还要去判断是不是同一个元素 很麻烦
一边遍历一边添加就不会出现这个问题

2、哈希表为什么用map
因为本题不仅要找满足条件的值 还要返回对应元素的下标
需要k-v键值对来保存数据

3、本题map是用来存什么的
存放遍历到的数组值和下标

4、map中的key和value用来存什么的
本题中 不能重复的实际是数组值 而不是数组下标
所以key保存数组值 val保存数组下标

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[0] = i;
                res[1] = map.get(temp);
            }else{
                map.put(nums[i],i);
            }
        }
        return res;
    }