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

空.白251

已于 2024-06-11 20:10:19 修改

阅读量956

点赞数 7

文章标签：算法

于 2024-06-11 20:10:00 首次发布

本文链接：https://blog.csdn.net/2301_79744698/article/details/139587308

版权

242. 有效的字母异位词

题目链接：

242. 有效的字母异位词 - 力扣（LeetCode）

题目要求：

给定两个字符串 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 仅包含小写字母

实现思路：

1.判定两个字符串长度是否相等，不相等返回false

2.. 初始化数组（result）：由于题目限制只包含小写字母，因此可以使用一个长度为26的数组 result 来存储每个字母出现的次数。数组索引0到25分别对应字母'a'到'z'。

3.遍历字符串s并增加计数：遍历字符串 s 中的每个字符，并使用 charAt(i) 方法获取当前字符。通过从当前字符中减去字符'a'的ASCII值，可以得到该字符在数组 result 中的索引，并将对应位置的计数增加1。

4.遍历字符串t并减少计数：同样地，遍历字符串 t 中的每个字符，并减少 result 数组中对应位置的计数。

5.遍历数组，如果数组中有元素不为0，则返回false，否则返回true

实现代码：

class Solution {
    public boolean isAnagram(String s, String t) {
        //如果数组长度不一致，直接返回false
        if (s.length() != t.length()) {
            return false;
        }
        //因为题目限制只有小写字母，所以数组长度26够用了
        //映射26个字母
        int []result=new int[26];
        //如果s数组中出现个某个元素，则让其在对应位置+1
        for (int i = 0; i < s.length(); i++) {
            //s.charAt()，根据索引获得对应的字符
            result[s.charAt(i)-'a']++;
        }
        //如果b数组中出现个某个元素，则让其在对应位置-1
        for (int i = 0; i < t.length(); i++) {
            result[t.charAt(i)-'a']--;
        }
        //遍历数组，如果result数组全部元素为非0，则返回false
        for(int i:result){
            if(i!=0){
                return false;
            }
        }
        return true;
    }
}

测试代码：

public class Test {
    /*示例 1:

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

        输入: s = "rat", t = "car"
        输出: false*/
    public static void main(String[] args) {
        Solution solution = new Solution();

        //示例1：
        String s1="anagram", t1= "nagaram";
        System.out.println(solution.isAnagram(s1,t1));

        //示例2：
        String  s2 = "rat", t2 = "car";
        System.out.println(solution.isAnagram(s2,t2));
    }
}

349. 两个数组的交集

题目链接：

349. 两个数组的交集 - 力扣（LeetCode）

题目要求：

给定两个数组 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.选择使用HashSet，其中的add方法自带去重，遍历nums1，把nums1添加到集合（set1）

2.创建另一个HashSet，遍历nums2，判断nums2中是否有与set1中有相同的元素，如果有，则让新集合（intersectionSet）保存它

3.初始化数组（result），数组长度为intersectionSet.size()，初始化索引位置（index）

4.遍历集合把元素赋值到数组上，索引增加

5.返回数组

实现代码：

import java.util.HashSet;


/*给定两个数组 nums1 和 nums2 ，返回 它们的交集
 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。*/
class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        // 使用HashSet存储nums1的唯一元素
        HashSet<Integer> set1 = new HashSet<>();
        for (int i = 0; i < nums1.length; i++) {
            set1.add(nums1[i]);
        }
        // 创建一个HashSet来存储交集元素，确保结果中的元素是唯一的
        HashSet<Integer> intersectionSet = new HashSet<>();
        for (int i = 0; i < nums2.length; i++) {
            if (set1.contains(nums2[i])) {
                intersectionSet.add(nums2[i]);
            }
        }
        // 将HashSet转换为数组
        int index=0;
        int[] result = new int[intersectionSet.size()];
        for (int num:intersectionSet){
            result[index++]=num;
        }
        return result;
    }
}

测试代码：

public class Test {
    public static void main(String[] args) {
        /*示例 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] 也是可通过的*/
        Solution solution = new Solution();

        //示例1：
        int []nums01={1,2,2,1};
        int []nums02={2,2};
        int [] result012=solution.intersection(nums01,nums02);
        for(int i=0;i<result012.length;i++){
            System.out.print(result012[i]+" ");
        }
        System.out.println();
        //示例2：
        int[]nums11={4,9,5};
        int []nums22={9,4,9,8,4};
        int[]result112=solution.intersection(nums11,nums22);
        for(int i=0;i<result112.length;i++){
            System.out.print(result112[i]+" ");
        }
        System.out.println();
    }
}

202. 快乐数

题目链接：

202. 快乐数 - 力扣（LeetCode）

题目要求：

编写一个算法来判断一个数 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

实现思路：

创建一个 HashSet（或等效的数据结构）来存储已经出现过的数字，以便检测循环。

2.进入循环，当n不为1并且集合中没有包含n，往集合中添加n，调用一个自定义的方法让n=getNextNumber(n)

3.写一个辅助方法返回该整数每个数字的平方和。，定义一个sum用来存n的每个数字的平方和，当n>0时，定义一个digit用来存n的单个位数值，令sum+=digit*digit，除掉低位的位置num=num/10

4.返回，判断最后n==1为真，返会true；n!=1为假，返回false

实现代码：

import java.util.HashSet;

class Solution {
    /*编写一个算法来判断一个数 n 是不是快乐数。

   「快乐数」 定义为：

    对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
    然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
    如果这个过程 结果为 1，那么这个数就是快乐数。
    如果 n 是 快乐数 就返回 true ；不是，则返回 false 。*/
    public boolean isHappy(int n) {
        //定义HashSet集合
        HashSet<Integer> set = new HashSet<>();
        //当n不为1并且集合中没有包含过该值
        while(n!=1&&!set.contains(n)){
            set.add(n);         //往集合中添加n
            n=getNextNumber(n);//获取下一个数
        }
        // 如果 n 变成了 1，则返回 true；否则返回 false（因为 n 进入了循环）
        return n==1;
    }
    // 辅助方法：计算一个数的每个数字的平方和
    private int getNextNumber(int num){
        int sum=0;
        while(num>0){
            //定义n的位数
            int digit = num%10;
            sum+=digit*digit;
            num=num/10;
        }
        return sum;
    }
}

测试代码：

public class Test {
    public static void main(String[] args) {
        /*示例 1：

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

        输入：n = 2
        输出：false*/
        Solution solution = new Solution();

        //示例1：
        int n1=19;
        System.out.println(solution.isHappy(n1));

        //示例2：
        int n2=2;
        System.out.println(solution.isHappy(n2));
    }
}

1. 两数之和

题目链接：

1. 两数之和 - 力扣（LeetCode）

题目要求：

给定一个整数数组 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]

实现思路：

1.创建HashMap集合（map）

2.遍历数组，用临时变量（temp）存储目标值与该位置元素的差值

3.判断如果map集合中包含temp，直接返回一个新数组，由temp在map集合上的索引和i构成

；否则，map保存该数组的索引和元素；

4.不满足上述条件，返回null

实现代码：

import java.util.HashMap;
import java.util.HashSet;
/*给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

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

你可以按任意顺序返回答案。*/
class Solution {
    public int[] twoSum(int[] nums, int target) {
        //创建HashMap
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        //遍历数组
        for (int i = 0; i < nums.length; i++) {
            //用临时变量保存目标值与该数组位置元素的差值
           int temp = target - nums[i];
           //判断集合中的是否有这个key
           if (map.containsKey(temp)) {
               //如果直接一起返回二者索引
               return new int[]{map.get(temp), i};
           }
           else {
               //如果没有保存该元素
               map.put(nums[i], i);
           }

        }
        // 如果没有找到和为target的两个数，返回null  
        return null;


    }
}

测试代码：

public class Test {
    public static void main(String[] args) {
        /*示例 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]*/

        Solution solution = new Solution();

        //示例1：
        int []nums1={2,7,11,15};
        int target1=9;
        int []nums01=solution.twoSum(nums1,target1);
        for(int i:nums01){
            System.out.print(i+" ");
        }
        System.out.println();
        //示例2：
        int []nums2={3,2,4};
        int target2=6;
        int[]nums02= solution.twoSum(nums2,target2);
        for(int i:nums02){
            System.out.print(i+" ");
        }
        System.out.println();
        //示例3：
        int[]nums3={3,3};
        int target3=6;
        int[]num03= solution.twoSum(nums3,target3);
        for(int i:num03){
            System.out.print(i+" ");
        }
        System.out.println();

    }
}

空.白251

关注

7
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
代码随想录算法训练营第五天|242. 有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和

定义一个sum用来存n的每个数字的平方和，当n>0时，定义一个digit用来存n的单个位数值，令sum+=digit*digit，除掉低位的位置num=num/10。2.创建另一个HashSet，遍历nums2，判断nums2中是否有与set1中有相同的元素，如果有，则让新集合（intersectionSet）保存它。2.进入循环，当n不为1并且集合中没有包含n，往集合中添加n，调用一个自定义的方法让n=getNextNumber(n)4.返回，判断最后n==1为真，返会true；
复制链接

扫一扫

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

242. 有效的字母异位词

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

测试代码：

349. 两个数组的交集

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

测试代码：

202. 快乐数

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

测试代码：

1. 两数之和

题目链接：

题目要求：

题目用例：

实现思路：

实现代码：

测试代码：

“相关推荐”对你有帮助么？