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

南瓜骨头

已于 2023-06-07 13:36:08 修改

阅读量50

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法 java 哈希表

于 2023-04-11 22:33:02 首次发布

本文链接：https://blog.csdn.net/weixin_47957908/article/details/130068619

版权

LeetCode 专栏收录该内容

52 篇文章 0 订阅

订阅专栏

242. 有效的字母异位词

题目

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
在这里插入图片描述
来源：力扣（LeetCode）
链接：有效的字母异位词

排序

时间复杂度：O(nlogn)
空间复杂度：O(logn)

class Solution {
    public boolean isAnagram(String s, String t) {
        //判断长度是否一样，提前过滤掉长度不一样的字符串，后面就没有运行的必要
        if(s.length() != t.length()){
            return false;
        }
        //toCharArray():把字符串转换成char数组
        char[] cs = s.toCharArray();
        char[] ct = t.toCharArray();
        //Arrays.sort():数组排序
        Arrays.sort(cs);
        Arrays.sort(ct);
        //Arrays.equals():判断数组是否相同
        return Arrays.equals(cs, ct);
    }
}

哈希表

思路

时间复杂度：O(m + n)
空间复杂度：O(1)

int[] arr = new int[26]; // 如下图

在这里插入图片描述

// 如下图
// 在新数组里计算“s”中个字母出现的次数 
for(int i = 0; i < s.length(); i++){
    //char charAt(int index):括号内是多少，就代表了字符串位置，从0开始计算
    char c = s.charAt(i);
    arr[c - 'a']++;
    // arr[s.charAt(i) - 'a']++;
}

在这里插入图片描述

// 如下图
for(int i = 0; i < t.length(); i++){
    char c = t.charAt(i);
    arr[c - 'a']--;
    //如果有字母扣到负数，证明该字母在“t”中出现的次数 != 在“s”中出现的次数，因此两个字符串不相等
    if(arr[c - 'a'] < 0){
        return false;
    }
}

在这里插入图片描述

class Solution {
    public boolean isAnagram(String s, String t) {
        //判断长度是否一样，提前过滤掉长度不一样的字符串，后面就没有运行的必要
        if(s.length() != t.length()){
            return false;
        }
        int[] arr = new int[26];
        //在新数组里计算“s”中个字母出现的次数
        for(int i = 0; i < s.length(); i++){
            //char charAt(int index):括号内是多少，就代表了字符串位置，从0开始计算
            char c = s.charAt(i);
            arr[c - 'a']++;
            // arr[s.charAt(i) - 'a']++;
        }
        //把已经计算好的数组通过遍历“t”进行相减
        //如果是字母相同但位置不同的字符串（字母异位），就会将数组中的值扣光
        for(int i = 0; i < t.length(); i++){
            char c = t.charAt(i);
            arr[c - 'a']--;
            //如果有字母扣到负数，证明该字母在“t”中出现的次数 != 在“s”中出现的次数，因此两个字符串不相等
            if(arr[c - 'a'] < 0){
                return false;
            }
        }
        return true;
    }
}

349.两个数组的交集

题目

给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。
在这里插入图片描述
链接：两个数组的交集

创建两个集合

时间复杂度：O(n1+n2)，n1+n2是数组长度
空间复杂度：O(n1+n2)，n1+n2是数组长度

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        //创建两个集合，Set：去重和排序
        Set<Integer> s1 = new HashSet<Integer>();
        Set<Integer> s2 = new HashSet<Integer>();
        //强循环，将经过去重和排序的两个数组存入到集合中
        for(int num : nums1){
            s1.add(num);
        }
        for(int num : nums2){
            s2.add(num);
        }
        return IntersectionValue(s1, s2);
    }
    public int[] IntersectionValue(Set<Integer> s1, Set<Integer> s2){
        //递归，找出最少的集合
        if(s1.size() > s2.size()){
            return IntersectionValue(s2, s1);
        }
        Set<Integer> intersectionSet = new HashSet<Integer>();
        //存入两个集合共有的数值
        for(int num : s1){
            if(s2.contains(num)){
                intersectionSet.add(num);
            }
        }
        int[] intersection = new int[intersectionSet.size()];
        int index = 0;
        //将数值输出
        for(int num : intersectionSet){
            intersection[index++] = num;
        }
        return intersection;
    }
}

创建两个集合（精简版）

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
            return new int[0];
        }
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> resSet = new HashSet<>();
        //遍历数组1
        for (int i : nums1) {
            set1.add(i);
        }
        //遍历数组2的过程中判断哈希表中是否存在该元素
        for (int i : nums2) {
            if (set1.contains(i)) {
                resSet.add(i);
            }
        }
        // 申请一个数组存放setRes中的元素,最后返回数组
        int[] arr = new int[resSet.size()];
        int j = 0;
        for(int i : resSet){
            arr[j++] = i;
        }
        return arr;
    }
}

202.快乐数

题目

编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。
如果这个过程结果为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 true ；不是，则返回 false
在这里插入图片描述
来源：力扣（LeetCode）
链接：快乐数

快慢指针法（双指针法）

时间复杂度：O(logn)
空间复杂度：O(1)

class Solution {
    public boolean isHappy(int n) {
        int slow = n;
        int fast = getHappy(n);
        while(fast != 1 && slow != fast){
            slow = getHappy(slow);
            fast = getHappy(getHappy(fast));
        }
        return fast == 1;
    }
    public int getHappy(int n){
        int happy = 0;
        while(n > 0){
            int s = n % 10;
            n = n / 10;
            happy += s * s;
        }
        return happy;
    }
}

哈希集合

时间复杂度：O(logn)
空间复杂度：O(logn)

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> happySet = new HashSet<Integer>();
        while(n != 1 && !happySet.contains(n)){
            happySet.add(n);
            n = getHappy(n);
        }
        return n == 1;
    }
    public int getHappy(int n){
        int happy = 0;
        while(n > 0){
        	// 取个位数
            int s = n % 10;
            // 取十位数
            n = n / 10;
            happy += s * s;
        }
        return happy;
    }
}

1.两数之和

题目

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
在这里插入图片描述
来源：力扣（LeetCode）
链接：两数之和

重点

为什么会想到用哈希表
哈希表为什么用map
本题map是用来存什么的
map中的key和value用来存什么的

思路

在遍历数组中，将目标值与数组中的元素相减，得出的数值，去查找是否有相同的数组元素，并将其放入到新建的数组中。

哈希Map

时间复杂度: O(n)
空间复杂度: O(n)

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] res = new int[2];
        if(nums == null || nums.length == 0) return nums;
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            // 遍历当前数组，在map中找到适当的key值
            int temp = target - nums[i];
            if(map.containsKey(temp)){
                res[0] = i;
                res[1] = map.get(temp);
                break;
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.put(nums[i], i);
        }
        return res;
    }
}

哈希Map（精简版）

时间复杂度: O(n)
空间复杂度: O(n)

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

南瓜骨头

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode：242. 有效的字母异位词 && 349.两个数组的交集 && 202.快乐数 && 1.两数之和

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。来源：力扣（LeetCode）链接：https://leetcode.cn/problems/valid-anagram。
复制链接

扫一扫

专栏目录