代码随想录Day6-哈希表01 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和

242. 有效的字母异位词

        这题直接用字符串判断了。。哈希感觉多余了是不??????

class Solution {
    public boolean isAnagram(String s, String t) {
        char[] s1 = s.toCharArray();//s变成字符数组
        Arrays.sort(s1);//字符数组排序
        String s2 = String.valueOf(s1);//数组转成字符串
        char[] t1 = t.toCharArray();//t同理
        Arrays.sort(t1);
        String t2 = String.valueOf(t1);
        return s2.equals(t2);//equals方法判断相等
    }
}

        如果首先判断两字符串长度是否相等可以节省部分时间(长度都不相等了后面也不用判断了),且最后也没必要数组转字符串,直接Arrays.equals(s1, t1);判断数组是否相等就好。

349. 两个数组的交集

        这个想法有点复杂而且效率是真低

        执行用时:5 ms, 在所有 Java 提交中击败了13.05%的用户

        5555555

        先对两个数组进行排序,排好序后用双指针遍历两数组,找到相同的数放到HashSet中,可以起到添加的同时去除重复元素的效果,最后再用stream流把HashSet转成数组返回。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int i = 0, j = 0;
        //排序
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        //两数组中相同的元素放到h中,同时去重
        HashSet<Integer> h = new HashSet<>();
        while(i < nums1.length && j < nums2.length){
            if(nums1[i] == nums2[j]){
                h.add(nums1[i]);
                i++;
                j++;
            }else if(nums1[i] < nums2[j]){
                i++;
            }else{
                j++;
            }
        }
        //把HashSet转成数组
        return h.stream().mapToInt(x -> x).toArray();
    }
}

        官解:没用HashSet,直接创建一个数组,每次判断加进数组的数跟前一个相不相等就可以实现去重了,因为数组长度不可控,使用index变量记录数组存了多少数进去,最后再截取数组的0~index就好啦。

        👇借鉴了大佬的哈希做法,很妙哇,把nums1先全部加进set1里,再把nums2中set1包含的元素加进set2中,妙蛙妙蛙!

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

202. 快乐数

        一开始一点也不快乐,后来写出来了:happy happy happy

        一开始写不出来的原因是脑子被囚禁了,想要用递归和哈希表,但是因为这个isHappy函数返回的是布尔类型,一时间不知道怎么用,而且如果递归的话肯定不能在递归函数里面用哈希表存数据。后来才想到可以自己写一个新的函数然后用while循环解决😂,笨笨捏

        思路:首先创建一个happy函数,计算每一次的平方和。在isHappy函数中,使用哈希表判断平方和是否出现过,把添加happy结果(平方和)到哈希表中当作循环条件,如果happy结果没有出现过,则成功添加到哈希表中,如果出现过,添加失败,循环条件不成立,直接退出循环,也就能判断它不是快乐数(原因是如果一个数第二次出现,再做相同的产生平方数操作,会陷入死循环)。

        循环内,将happy结果重新赋值给他自己,保证能够循环产生新的happy结果,如果这个结果等于1,说明找到快乐数。

class Solution {
    public boolean isHappy(int n) {
        HashSet<Integer> h = new HashSet<>();
        while(h.add(happy(n))){
            n = happy(n);
            if(n == 1){
                return true;
            }
        }
        return false;
    }
    //happy函数用来得到每一个平方和
    public int happy(int n){
        int sum = 0;
        while(n != 0){
            int temp = n % 10;
            sum += temp * temp;
            n /= 10;
        }
        return sum;
    }
}

        官解还有快慢指针和数学方法!好聪明,有空来看~

1. 两数之和

        暴力解法,不暴力不会啊嘤嘤嘤

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for(int i = 0; i< nums.length; i++){
            for(int j = i+1; j < nums.length; j++){
                if(nums[i] + nums[j] == target){
                    return new int[]{i,j};
                }
            }
        }
        return new int[]{0};
    }
}

        官解!我的神

        创建HashMap保存数和数的下标,遍历数组,在HashMap中找另一个数(target - nums[i]),找到直接返回,找不到就把当前 nums[i], i 放到表中

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

        下次一定要自己写出来这个解法qwq👆

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值