Day5(哈希表) |242.有效的字母异位词 & 349.两个数组的交集 & 202.快乐数&1.两数之和

242.有效的字母异位词

给定两个字符串 *s* 和 *t* ，编写一个函数来判断 *t* 是否是 *s* 的字母异位词。

注意：若 *s* 和 *t* 中每个字符出现的次数都相同，则称 *s* 和 *t* 互为字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

方法一:此题十分简单,使用Arrays.sort方法排序后比较即可

方法二:哈希表的方式也很通俗易懂,用table 数组记录字符串s中每个字母出现的次数,然后依次取出t字符串中的字母,映射到table数组中,使得table数组中相应的元素值减一,如果s和t完全相同,那么table数组中每个元素会全部减为0,如果发现table数组中哪个元素的值小于0的话,那么一定是不匹配的.

代码如下:

public boolean isAnagram1(String s, String t) { //使用java内置方法
        if (s.length() != t.length()) return false;
        char[] charArray1 = s.toCharArray();
        char[] charArray2 = t.toCharArray();
        Arrays.sort(charArray1);
        Arrays.sort(charArray2);
        return Arrays.equals(charArray1, charArray2);
    }

    public boolean isAnagram2(String s, String t) {//使用哈希表
        if (s.length() != t.length()) return false;
        int[] table = new int[26];
        for (int i = 0; i < s.length(); i++) {
            table[s.charAt(i) - 'a']++;
        }
        for (int i = 0; i < t.length(); i++) {
            table[t.charAt(i) - 'a']--;
            if (table[t.charAt(i) - 'a'] <0){
                return  false;
            }
        }
        return true;
    }

349.两个数组的交集

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

示例 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] 也是可通过的

思路 : 我将两个数组num1和num2转为HashSet,这样做可以把数组中的重复元素去掉,接着我使用Set集合中的contains方法判断set2集合中的是否包含了set1中的某个元素,如果包含将结果放入result集合中,最后我将result集合转为了resultArray数组返回

代码如下:

public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();
        for (int num : nums1) {
            set1.add(num);
        }
        for (int num : nums2) {
            set2.add(num);
        }
        return getIntersection(set1,set2);
    }

    public int[] getIntersection(Set<Integer> set1, Set<Integer> set2) {
        if (set1.size() > set2.size()) return getIntersection(set2, set1);

        Set<Integer> result = new HashSet<>();
        for (Integer next : set1) {
            if (set2.contains(next)) result.add(next);
        }

        int[] resultArray = new int[result.size()];
        Iterator<Integer> iterator1 = result.iterator();
        int index = 0;
        while (iterator1.hasNext()) {
            Integer next = iterator1.next();
            resultArray[index++] = next;
        }
        return resultArray;
    }

202.快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例 2：

输入：n = 2
输出：false

思路 : 把每次平方和的记录记入seen集合中,判断这次返回的n值在不在seen中,如果不在的话,并且n还不等于1,那么继续进入算平方和的方法中计算,重复以上步骤,直到发现返回的结果在seen中存在或者n为1为止,最后返回的值是n是否为1,如果为1那么就是所给参数就是快乐数,否则就不是快乐数.

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

    public int getSqr(int n) {
        int total = 0;
        int d;
        while (n > 0) {
            d = n % 10;
            n = n / 10;
            total += d * d;
        }
        return total;
    }

1.两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

这题很久之前就写过,但不是用的Map集合写的,这次用Map集合修改了

我用table引用保存了一个Map集合的对象,接着遍历数组nums,如果table中有key值等于(即containsKey返回值为true)target-nums[i],那么返回,返回值是一个数组result,包含了两个元素的下标,分别是table.get(target.nums[i])和i.
如果table中所有key值不等于target-nums[i],(即containsKey返回值为false),则把nums[i]和i的值加入table中即可

代码如下:

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