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

242.有效的字母异位词

• 题目描述

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

• 思路

哈希法–数组
范围有限，数字不是很大就可以用数组的方法

• 代码随想录视频讲解链接：https://www.bilibili.com/video/BV1YG411p7BA/?vd_source=110bab21cbd93149da7eacba5f850b6b

class Solution {
    public boolean isAnagram(String s, String t) {
        /**
        数组初始化的方法：
        静态初始化--int[] ret = {0,1,2};
        动态初始化--int[] ret = new int[6];for循环赋值
        默认初始化--int[] ret = new int[6];默认为0
         */
        int[] ret = new int[26];

        for(int i = 0; i < s.length(); i++){
            ret[s.charAt(i) - 'a']++;
        }
        for(int i = 0; i < t.length(); i++){
            ret[t.charAt(i) - 'a']--;
        }
        for(int i = 0; i < 26; i++){
            if(ret[i] != 0){
                return false;
            }
        }
        return true;
    }
}

349.两个数组的交集

• 题目描述

给定两个数组，编写一个函数来计算它们的交集。

• 思路

如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费
直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的

• 知识点

if(nums == null || nums.length == 0):
对象和数据在java中都是引用数据类型，就是可以指向一个heap中的内存，这个变量保存的是地址。

1. 对于对象，如果只定义了，没有引用，那么这个值默认就是null。

Integer i;//null

2. 对于数组，有两种。

int[] nums;//nums=null
int[] nums=new int[0]//nums.length=0;

null的情况声明了变量但是没有赋值，nums.length=0是栈中变量指向了堆中的一块区域，只不过这块区域的长度是0。
平时写代码可以加上，同时也要注意顺序，先判断是否为null然后再判断长度是否为0，否则会出现空指针异常。

• 代码随想录视频讲解链接：https://www.bilibili.com/video/BV1ba411S7wu/

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        //1、哈希法--set
        if(nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0){
            return new int[0];
        }
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> ret = new HashSet<>();

        for(int i : nums1){//把nums1加入集合
            set1.add(i);
        }
        for(int i : nums2){
            if(set1.contains(i)){
                ret.add(i);
            }
        }
        //将结果集合ret转为要求返回类型数组
        /**
        int[] arr = new int[ret.size()];
        int i = 0;
        for(int j : ret){
            arr[i++] = j;
        }
        return arr;
         */
        return ret.stream().mapToInt(x -> x).toArray();
    }
}

数据量<1000，数组方法↓

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int[] arr1 = new int[1002];
        int[] arr2 = new int[1002];
        for(int i : nums1){
            arr1[i] = 1;
        }
        for(int i : nums2){
            arr2[i] = 1;
        }
        List<Integer> retList = new ArrayList<>();
        for(int i = 0; i < 1002; i++){
            if(arr1[i] == 1 && arr2[i] == 1){
                retList.add(i);
            }
        }
        int[] retArr = new int[retList.size()];
        int index = 0;
        for(int i : retList){
            retArr[index++] = i;
        }
        return retArr;
    }
}

202.快乐数

• 题目描述

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

• 思路：不太理解，先赶个进度吧
• 代码随想录文字讲解链接：https://programmercarl.com/0202.%E5%BF%AB%E4%B9%90%E6%95%B0.html#%E6%80%9D%E8%B7%AF

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> record = new HashSet<>();
        //n随时在变，只要n不等1，无法判断是否快乐数就一直遵循规则寻找下一个数
        while(n != 1 && !record.contains(n)){
            record.add(n);
            n = getNextNumber(n);
        }
        //要不n==1，要不n在record里??(不理解)
        return n == 1;
    }

    private int getNextNumber(int n){
        int ret = 0;
        //n = 单个数字平方和
        while(n > 0){
            int tmp = n % 10;
            ret += tmp * tmp;
            n = n / 10;
        }
        return ret;
    }
}

1.两数之和

• 题目描述

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

• 思路：HashMap
• 代码随想录视频讲解链接：https://www.bilibili.com/video/BV1aT41177mK/

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] ret = new int[2];
        if(nums == null || nums.length == 0){
            return ret;
        }
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            int tmp = target - nums[i];
            if(map.containsKey(tmp)){
                ret[0] = map.get(tmp);
                ret[1] = i;
                break;
            }
            map.put(nums[i], i);
        }
        return ret;
    }
}