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

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

第一题 242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

ψ(｀∇´)ψ 我的思路

这是我拿到题一开始的思路，两个字符串装到俩个map中，再进行比较

package hash;

import java.util.HashMap;
import java.util.Set;

class IsAnagram {
    public static boolean isAnagram(String s, String t) {
        char c;
        HashMap<Character, Integer> smap = new HashMap<>();
        int len = s.length();//字符串的长度
        for (int i = 0; i < len; i++) {
            c = s.charAt(i);//挨个取出s字符串中的每一个字符
            if(smap.containsKey(c)){//如果key中已有c
                smap.put(c,smap.get(c)+1);//把c中原来的值+1再赋给c
            } else {
                smap.put(c,1);//如果key中没有c，添加c并赋值1
            }
        }

        HashMap<Character, Integer> tmap = new HashMap<>();
        for (int i = 0; i < len; i++) {
            c = t.charAt(i);//挨个取出t字符串中的每一个字符
            if(tmap.containsKey(c)){//如果key中已有c
                tmap.put(c,tmap.get(c)+1);//把c中原来的值+1再赋给c
            } else {
                tmap.put(c,1);//如果key中没有c，添加c并赋值1
            }
        }
        if(smap==tmap){
            return true;
        }else {
            return false;
        }
    }

    public static void main(String[] args) {
        String s = "anagram";
        String t = "nagaram";
        System.out.println(isAnagram(s, t));
    }
}

后来debug发现==判断的是两个map的地址
改进后的思路:只用一个map，第一个字符串存，第二个字符串取

public static boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()){
            return false;//长度都不等，你还比个什么呢，返回吧
        }
        char c;
        HashMap<Character, Integer> map = new HashMap<>();
        int len = s.length();//字符串的长度
        for (int i = 0; i < len; i++) {
            c = s.charAt(i);//挨个取出s字符串中的每一个字符
            if(map.containsKey(c)){//如果key中已有c
                map.put(c,map.get(c)+1);//把c中原来的值+1再赋给c
            } else {
                map.put(c,1);//如果key中没有c，添加c并赋值1
            }
        }

        for (int i = 0; i < len; i++) {
            c = t.charAt(i);//挨个取出t字符串中的每一个字符
            if(map.containsKey(c)){//如果key中已有c
                map.put(c,map.get(c)-1);//把c中原来的值-1再赋给c
                if (map.get(c)==0){
                    map.remove(c);//当c的值减到0的时候移除c
                }
            } else {
                return false;//如果key中没有c，直接返回false
            }
        }
        if(map.isEmpty()){
            return true;
        }else {
            return false;
        }
    }

通过之后我在写博客的时候发现只要将第一种方法的==换成equal就也可以通过😅
看了官方题解，是字符串转成char[]后排序比较，就😶

第二题349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。

ψ(｀∇´)ψ 我的思路

先把两个数组存到set里保证他们不重复，把其中一个set转成数组，不然没法遍历，第一遍遍历数组确定交集元素的数量，这样才能创建数组，第二遍遍历数组把交集元素存到数组中

package hash;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class Intersection {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new TreeSet<>();
        for (int i = 0; i < nums1.length; i++) {
            set1.add(nums1[i]);//把数组中的元素装到set里，确保每个元素只出现一次
        }
        Object[] arr1 = set1.toArray();//

        Set<Integer> set2 = new HashSet<>();
        for (int i = 0; i < nums2.length; i++) {
            set2.add(nums2[i]);//把数组中的元素装到set里，确保每个元素只出现一次
        }
        int j = 0;
        for (int i = 0; i < arr1.length; i++) {
            if(set2.contains(arr1[i])){
               j++;//这次遍历是为了得到数组的长度
            }

        }
        int[] res = new int[j];
        j = 0;
        for (int i = 0; i < arr1.length; i++) {
            if(set2.contains(arr1[i])){
                res[j++] = (int) arr1[i];//交集元素存入数组
            }

        }
        return res;
    }
}

下面是代码随想录中的解法

import java.util.HashSet;
import java.util.Set;

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> resSet = new HashSet<>();
        //遍历数组1
        for (int i : nums1) {
            set1.add(i);
        }
        //遍历数组2的过程中判断哈希表中是否存在该元素
        for (int i : nums2) {
            if (set1.contains(i)) {
                resSet.add(i);
            }
        }
        //将结果几何转为数组
        return resSet.stream().mapToInt(x -> x).toArray();
    }
}

我觉得这个解法挺好，把一个数组转成set，留了一个用来遍历，交集元素存入新set，最后set转array，这算是对我的解法的改进

第三题202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。
如果这个过程结果为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 true ；不是，则返回 false 。

ψ(｀∇´)ψ 我的思路

这题复杂是复杂了点，但顺着思路写还行，我目前写的程序可以把快乐数判断出来，返回true，不是快乐数的会一直循环所以超时的就不是快乐数🤪
我现在可以把任何一个整形判断出来是不是快乐数但是却没法通过leetcode😅，因为我找不到结束循环的条件

package hash;

public class IsHappy {

    public static boolean isHappy(int n) {
        int sum = 0;
        int[] ints = intToInts(n);
        while (sum!=1){
            for (int i = 0; i < ints.length; i++) {
                sum +=ints[i]*ints[i];
            }
            if(sum==1){
                return true;
            }
            ints = intToInts(sum);
            sum = 0;
        }
        return true;
    }

    private static int[] intToInts(int n){
        // 先写一个方法把整数拆成数组
        int i = 1;
        int x = n;
        while (x/10!=0){
            x = x/10;
            i++;//确定整数的位数
        }
        int[] ints = new int[i];
        for (int j = 0; j < i; j++) {
            ints[j] = n%10;
            n = n/10;
        }
        return ints;
    }
}

我回去又把题目看了一遍，

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

这就好办了，我把每一次计算出的sum记录下来，存在set中，sum在set中重复的时间点就是我该跳出循环的位置。

package hash;

import java.util.HashSet;
import java.util.Set;

public class IsHappy {

    public static boolean isHappy(int n) {
        int sum = 0;
        Set<Integer> set = new HashSet<>();
        int[] ints = intToInts(n);
        while (sum!=1){
            for (int i = 0; i < ints.length; i++) {
                sum +=ints[i]*ints[i];
            }
            if(!set.contains(sum)){//如果set中没有出现过sum
                set.add(sum);//把sum都加入到set中
            } else {//如果set中已经有sum，说明已经开始循环
                return false;
            }
            if(sum==1){
                return true;
            }
            ints = intToInts(sum);
            sum = 0;
        }
        return true;
    }

    private static int[] intToInts(int n){
        // 先写一个方法把整数拆成数组
        int i = 1;
        int x = n;
        while (x/10!=0){
            x = x/10;
            i++;//确定整数的位数
        }
        int[] ints = new int[i];
        for (int j = 0; j < i; j++) {
            ints[j] = n%10;
            n = n/10;
        }
        return ints;
    }
}

第四题1. 两数之和

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

这这这，这不就是梦开始的地方嘛，这就是我注册leetcode那天写的题，把当时的代码粘下

class Solution {
    public int[] twoSum(int[] nums, int target) {
         int[] result = new int[2];
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length ; j++) {
                if((nums[i]+nums[j])==target){
                    result[0] = i;
                    result[1] = j;
                }
            }
        }
        return result;
    }
}

就是暴力！！！

ψ(｀∇´)ψ 我的思路

其实我想半天也没有想到用哈希表做题的思路，然后我就看了代码随想录的思路，真的是妙蛙种子吃了妙脆角妙到家啦hhh

package hash;

import java.util.HashMap;
import java.util.Map;

public class TwoSum {
    public static int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        int[] res = new int[2];
        for (int i = 0; i < nums.length; i++) {
            //将数组的元素作为key，数组下标作为value存入map
            if(map.containsKey(target-nums[i])){//如果map中已经加入了要寻找的值
                res[0] = map.get(target-nums[i]);
                res[1] = i;//当前值的下标
            }
            map.put(nums[i],i);
        }
        return res;
    }
}