代码随想录35期Day06（Day05休息）-Java

Day06题目

LeetCode242 判断字母异位词：字母一样，排列不同的词称作异位词

核心思想：记录单词的每个字母及其个数。直接使用hashmap记录字母个数不如数组简单，而且数组性能好。

class Solution {
    public boolean isAnagram(String s, String t) {
   		// 创建一个数组，记录每个字母的个数
        int[] record = new int[26];
        // s中有的就加一
        for(int i = 0 ; i < s.length() ; i ++){
            // 小写字母字符-'a'就是以'a'为0的对应数字，比如'b'-'a'=1
            int index = s.charAt(i)-'a';
            record[index] = record[index]+1;
        }
        // t中有-1
        for(int i = 0 ; i < t.length() ; i ++){
            int index = t.charAt(i)-'a';
            record[index] = record[index]-1;
        }
        // 结果中record均为0则是异位词，否则不是
        for(int i = 0 ; i < record.length; i ++ ){
            if(record[i] != 0){
                return false;
            }
        }
        return true;
    }
}

LeetCode349：两个数组的交集元素，要求去重

核心思想：使用HashSet完成去重，并且可以判断是否重复。但LeetCode的测试用例范围较小，只有1000个元素，每个元素大小也在1000内，也可以直接开1001大小的数组记录，类似上一题，效率比set高。

// 使用HashSet
class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> set = new HashSet<>();
        for (int num : nums1) {
            if (!set.contains(num)) {
                set.add(num);
            }
        }
        ArrayList<Integer> list = new ArrayList<>();
        for (int num : nums2) {
            if (set.contains(num) && !list.contains(num)) {
                list.add(num);
            }
        }
        int[] res = new int[list.size()];
        for (int i = 0; i < list.size(); i++) {
            res[i] = list.get(i);
        }
        return res;
    }
}

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // 使用两个数组
        int[] record1 = new int[1001];
        int[] record2 = new int[1001];
        for (int num : nums1) {
            record1[num]++;
        }
        for (int num : nums2) {
            record2[num]++;
        }
        ArrayList<Integer> res = new ArrayList<>();
        for (int i = 0; i < 1001; i++) {
            if (record1[i] > 0 && record2[i] > 0) {
            	// 说明两个数组中都有这个元素
                res.add(i);
            }
        }
        // arraylist转int[]
        int[] result = new int[res.size()];
        for (int i = 0; i < res.size(); i++) {
            result[i] = res.get(i);
        }
        return result;
    }
}

LeetCode202 快乐数：各个位的平方和为1的就是快乐数，平方和是快乐数的也是快乐数。

核心思想：将数字的各个位的平方和保存在set中，如果出现set原有的元素则说明不会是快乐数，在这个过程中判断如果平方和是1，则是快乐数

class Solution {
    static HashSet<Integer> set = new HashSet<>();
    public boolean isHappy(int n) {
    	// 每一个用例初始化一个空set
        set = new HashSet<>();
        return help(n);
    }
    public boolean help (int n ){
    	// 将数字转为字符数组，这样就不用取余求每一位了，但是这样空间占用增大
        char[] chars = String.valueOf(n).toCharArray();     
        int sum = 0 ;
        // 计算平方和
        for(int i= 0 ; i < chars.length; i ++){
            int num =  Integer.parseInt(chars[i]+"");
            sum += num*num;
        }
        if(sum == 1) return true;
        if(set.contains(sum)) return false;
        set.add(sum);
        // 判断这个数的平方和是不是快乐数
        return help(sum);
    }
}

// 使用取余计算，不使用递归，更简洁
class Solution {
    public boolean isHappy(int n) {
        HashSet<Integer> set = new HashSet<>();
        set = new HashSet<>();
        while(n != 1 && !set.contains(n) ){
            set.add(n);
            n = getNextNumber(n);
        }
        return n ==1 ;
    }

    private int getNextNumber(int n) {
        int res = 0;
        while (n > 0) {
            int temp = n % 10;
            res += temp * temp;
            n = n / 10;
        }
        return res;
    }
}

LeetCode001 两数之和：返回和为target的两个元素的index

核心思想：使用暴力也行。使用HashMap存储。元素的值作为key，元素的index作为value，之后使用index遍历数组，使用containsKey判断map中有没有target-nums[index]的值，有的话直接返回，没有的话就加入这个元素。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer,Integer> map = new HashMap<>();
        // 返回值 两个数的index
        int[] res = new int[2];
        for(int i = 0 ; i < nums.length; i ++){
            int num = nums[i];
            // 这里判断是否有符合条件的值
            if(map.containsKey(target-num)){
                res[0] = map.get(target-num);
                res[1] = i;
                return res;
            }
            map.put(num,i);
        }
        return res;
    }
}