242.有效的字母异位词

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

• 1 <= s.length, t.length <= 5 * 104
• s 和 t 仅包含小写字母

思路：题目给定字符串s和t中只包含小写字母，所以出现的字母为$[a,z]$，使用数组存储各字母出现 的频数，先遍历s，对各字母出现的频数进行统计，再遍历t，对每一个字母，将数组中对应位置的频数减1，待两次遍历完成后，若数组所有的元素全为$0$，则这两个字符串为字母异位词；否则，这两个字符串不是字母异位词。

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length()){
            return false;
        }

        int[] map=new int[26];

        for(int i=0;i<s.length();i++){
            map[s.charAt(i)-'a']+=1;
        }

        for(int i=0;i<t.length();i++){
            map[t.charAt(i)-'a']-=1;
        }

        for(int i=0;i<map.length;i++){
            if(map[i]!=0){
                return false;
            }
        }

        return true;
    }
}

349. 两个数组的交集

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

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 1000

思路：题目给出数组元素的取值范围为$0 - 1000$，使用长度1001的数组来标记nums1中是否存在这个元素，再在遍历nums2时，通过数组判断nums2的元素是否包含在nums1中，并将满足条件的元素加入到结果集中。注意：当将一个nums2的元素加入到结果集时，为避免nums2中还有相同的该元素被加入到结果集中，需要将数组中该元素标记为false。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        boolean[] set=new boolean[1001];
        List<Integer> res=new ArrayList<Integer>();

        for(int i=0;i<nums1.length;i++){
            set[nums1[i]]=true;
        }

        for(int i=0;i<nums2.length;i++){
            if(set[nums2[i]]==true){
                res.add(nums2[i]);
                //去重
                set[nums2[i]]=false;
            }
        }

        return Arrays.stream(res.toArray(new Integer[res.size()])).mapToInt(i ->i==null?null:i.intValue()).toArray();

    }
}

List<Integer>转int[]的方法：

• res的类型为List<Integer>
• res.toArray(new Integer[res.size()])):将res类型转为Integer[]
• Arrays.stream():使用java8的stramAPI，创建stream流
• .mapToInt():将Integer[]数组中的每一个元素的类型从Integer转成int
• .toArray():stramAPI的收集阶段，将计算结果生成一个数组

也可以直接使用Java提供的HashSet进行去重，代码如下：

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set1=new HashSet<Integer>();
        Set<Integer> resSet=new HashSet<Integer>();

        for(int num:nums1){
            set1.add(num);
        }

        for(int num:nums2){
            if(set1.contains(num)){
                resSet.add(num);
            }
        }


        return resSet.stream().mapToInt(x->x).toArray();
    }
}

202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」 定义为：

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

思路：使用一个HashSet记录计算快乐数过程中的每一个值，如果出现了重复的数字，那么之后的计算就是重复之前的操作，不会得到数字1，这个数字就不是快乐数。否则，重复计算过程，直到算出数字1为止。

class Solution {
    public boolean isHappy(int n) {
        if(n==1){
            return true;
        }

        Set<Integer> set=new HashSet<>();
        set.add(n);

        do{
            n=getNextNum(n);
            if(set.contains(n)){
                return false;
            }else if(n==1){
                return true;
            }
            set.add(n);
        }while(true);
    }

    //计算下一个数字
    private int getNextNum(int n){
        int sum=0;
        int num;
        do{
            num=n%10;
            n=n/10;
            sum+=num*num;
        }while(n>0);

        return sum;
    }
}

1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

思路：遍历nums数组，对于每一个数组元素，使用HashMap保存该元素与target的差以及该元素的下标；在遍历过程中，如果该元素在map中存在，则找到目标，将map保存的下标与当前元素的下标返回即可。

class Solution {
    public 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++){
            if(map.containsKey(nums[i])){
                res[0]=map.get(nums[i]);
                res[1]=i;
                return res;
            }else{
                map.put(target-nums[i],i);
            }
        }

        return res;
    }
}