力扣算法：242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和

菜菜要要努力

已于 2022-10-26 21:20:25 修改

阅读量801

点赞数

文章标签：算法 leetcode 数据结构

于 2022-09-26 21:41:16 首次发布

本文链接：https://blog.csdn.net/m0_51982291/article/details/127059536

版权

学习内容

242.有效的字母异位词

349. 两个数组的交集

202. 快乐数

1. 两数之和

数组、map、set的使用情况

具体内容

242.有效的字母异位词

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

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

示例 1:

输入: s = “anagram”, t = “nagaram” 输出: true

示例 2:

输入: s = “rat”, t = “car” 输出: false

提示:

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

题目链接

做题思路

题目是判断每个字符出现的次数，可以用简单的哈希表，即数组，用来表示字符s中的每个字符出现的次数，之后再遍历数组，若是字符串t与数组出现的元素相同，就-1，进而可判断字符串s和字符串t的字符到底是不是相同

解题

class Solution {
    public boolean isAnagram(String s, String t) {
    	 //若是长度不相等，则结果直接返回false
    	 if(s.length() != t.length()){
    	 	return false;
    	 } 
        //符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。
        //因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。
        int records[] = new int[26];
        //存放字符串s的值
        for(int i = 0;i < s.length;i++){
        	records[s.charAt(i) - 'a']++;
        }
        //若records中出现字符串t的字符，则-1
        for(int i = 0;i < t.length;i++){
        	records[t.charAt(i) - 'a']--;
        }
        //判断records中的元素是否为0
        for(int i : records){
        	if(i != 0){
        		return false;
        	}
        }
        return true;
    }
}

解答代码存在的疑问

1、为什么使用数组

利用字符映射到数组上，字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。再遍历字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。这样就将字符串s中字符出现的次数，统计出来了

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

提示：

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

题目地址

做题思路

由于题目要求输出结果是唯一，而由于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];
    	}
    	HashSet<Integer> set = new HashSet<>();
    	HashSet<Integer> result = new HashSet<>();
    	for(int i = 0;i < nums1.length;i++){
    		set.add(nums1[i]);
    	}
    	for(int i = 0;i < nums2.length;i++){
    		if(set.contains(nums2[i])){
    			result.add(nums2[i]);
    		}
    	}
    	//将结果几何转为数组
    	return result.stream().mapToInt(x -> x).toArray();
    }
 }

解答代码存在的疑问

1、为什么为空的时候是返回return new int[0]？

在代码写到for循环结束之后，对于应该返回一个什么样的值产生了分歧。在代码开始定义twoSum方法时，就已经定义返回值应该是int类型的数组，所以更合理的解释是返回return new int[0]（本身的含义是长度为0的数组****），定义在此处没有实际的意义，只是为了编译器编译过程中不出错。
同时，对返回值为return null，也进行了编译，编译结果也没有报错，但是个人觉得还是应该使用return new int[0];假设一个方法返回一个数组，如果它返回null，则调用方法必须先判断是否返回null，才能对返回数组进一步处理，而如果返回空数组，则无须null引用检查。鉴于此，返回数组的方法在没有结果时通常返回空数组，而不是null，这样做对于函数调用者的处理比较方便。

2、结果集合转化为数组？

mapToInt:对原数据进行转换处理，这里用的是集合，但返回值是数组，所以要转换一下

202. 快乐数

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

「快乐数」定义为：

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

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

提示：

1 <= n <= 231

题目链接

做题思路

1、先解决如何得出它每个位置上的数字的平方和
2、在判断最终结果是否为1

解题

class Solution {
    public boolean isHappy(int n) {
    	//建立一个set对象，这样才不会求得相同的平方和而一直死循环下去
    	HashSet<Integer> set = new HashSet<>();
    	while(n != 1 && !set.contains(n)){
    		set.add(n);
    		n = total(n);
    	}
    	return n == 1;
    }
    //求出整数每个位置上的数字的平方和
    public int total(int n){
    	int res = 0;
    	while(n > 0){
    		int temp = n%10;
    		res += temp*temp;
    		n = n/10;
    	}
    	return res;
    }

解答代码存在的疑问

1、为什么要建立对象set

由于可能存在整数的位置上所求的平方和是相同的，为了避免死循环，利用set不存放重复元素的特点，来避免这种情况的发生

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]

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

题目地址

做题思路

要返回两数之和为target对应的整数下标，因此可用map，key值存放整数，value存放其下标；另一个整数可用target-map现有的key值判断是否存在

解题

class Solution {
    public int[] twoSum(int[] nums, int target) {
    	Map<Integer,Integer> map = new HashMap<>();
    	//创建数组存放结果
    	int result[] = new int[2];
    	for(int i = 0;i < nums.length;i++){
    		//求其差值 放在map中进行查找相应的值
    		int temp = target - nums[i];
    		if(map.containsKey(temp)){
    			result[0] = i;
    			result[1] = map.get(temp);
    		}
    		map.put(nums[i],i);
    	}
        return result;
    }
}

解答代码存在的疑问

1、为什么要先判断map是否存在target-nums[i]相等的值

若是先把数组的元素存进链表里，极有可能导致数组中同一个元素在答案里会重复出现

数组、map、set的使用情况

1、set

输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的，同时可以不考虑输出结果的顺序；且哈希值比较少、特别分散、跨度非常大

2、数组

限制了大小

3、map

当需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

复习

242.有效的字母异位词

使用简单的哈希表，即数组

class Solution {
    public boolean isAnagram(String s, String t) {
    	//由于是用ASCII的方式 因此数组长度是26
    	int result[] = new int[26];
    	for(int i = 0;i < s.length;i++){
    		result[s.charAt(i) - 'a']++;
    	}
    	for(int j = 0;j < t.length;j++){
    		result[t.charAt(j) - 'a']--;
    	}
    	for(int count : result){
    		if(count != 0){
    			return false;
    		}
    	}
    	return true;
    }
 }

349. 两个数组的交集

逻辑复杂了

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        if(nums1.length > nums2.length){
            int result[] = new result[nums1.length];
        }else{
            int result[] = new int[nums2.length];
        }
        int j = 1;
        for(int i = 0; i < nums1.length;i++){
            if(map.get(nums1[i]) >= 1){
                map.put(nums1[i],map.get(nums1[i])+1);
            }else{
                map.put(nums1[i],j);
            }
        }
        for(int k = 0;k < nums2.length;k++){
            int num = map.get(nums2[k]);
            map.put(nums2[k],num--);
        }
        if(nums1.length > nums2.length){
            for(int l = 0;l < nums1.length;l++){
                if(map.get(nums1[l]) == 0){
                    result
                }

            }
        }
        }else{

        }
    }
}

为了没有重复，使用set结构

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
    	Set<Integer> set = new HashSet<>();
    	Set<Integer> set1 = new HashSet<>();
    	for(int i = 0 ;i < nums1.length;i++){
    		set.add(nums1[i]);
    	}
    	for(int j = 0;j < nums2.length;j++){
    		if(set.contains(nums2[j])){
    			set1.add(nums2[j]);
    		}
    	}
    	return set1.stream().mapToInt(x -> x).toArray();
    }
 }

202. 快乐数

完全不会

class Solution {
    public boolean isHappy(int n) {
    	//不能有重复的数，不然会陷入死循环
    	Set<Integer> set = new HashSet<>();
    	while(n != 1 || !set.contains(n)){
    		set.add(n);
    		n = sum(n);
    	}
    	return n ==1;
    }
    public int sum(int n){
    	int res = 0;
    	while(n>0){
    		int temp = n%10;
    		res += temp*temp;
    		n = n/10;
    	}
    	return res;
    }

1. 两数之和

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