代码随想录Day_06|Leetcode.242.349.202.1（HashMap HashSet ArrayList）

找茬豆沙包

已于 2024-02-26 17:43:03 修改

阅读量299

点赞数 3

CC 4.0 BY-SA版权

文章标签：哈希算法算法

于 2024-02-26 17:42:37 首次发布

本文链接：https://blog.csdn.net/m0_62452183/article/details/136298675

文章介绍了几个编程题目，涉及字符串异位词检测、数组交集计算、快乐数判断以及两数之和查找，展示了使用暴力法、辅助数组、哈希集合等技术来优化解决方案的过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

242.有效的字母异位词

暴力解法（超时）

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length())
            return false;
        int[] array = new int[t.length()];
        int flag = 0;
        int tag = 0;
        for (int i = 0; i < s.length(); i++) {
            for (int j = 0; j < t.length(); j++) {
                tag = 1;
                if (t.charAt(j) == s.charAt(i)) {
                    flag = 1;
                    if (array[j] == 0) {
                        array[j]++;
                        flag = 0;
                        tag = 0;
                        break;
                    }

                }
            }
            if (flag == 1 || tag == 1)
                return false;
        }
        return true;
    }

}

标准答案：

创建一个辅助数组，在字符之间+-代表数值运算，charAt（）将字符转化为ASCII码

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length()!=t.length())
            return false;
        int [] array=new int[26];
        for (int i = 0; i < s.length(); i++) {
            array[s.charAt(i)-'a']++;
        }
        for (int i = 0; i < t.length(); i++) {
            array[t.charAt(i)-97]--;
            if(array[t.charAt(i)-97]<0)
                return false;
        }
        return true;
    }
}

349.两个数组的交集

set和list可变长

创立一个HashSet将nums1元素添加进这个集合，保证没有重复，然后再将set1的元素与nums2比较，相同的加入新的reset集合，最后返回一个数组

import java.util.HashSet;
import java.util.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];
        }
        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);
            }
        }

        //方法1：将结果集合转为数组

        int[] arr = new int[resSet.size()];
        int j = 0;
        for (int i : resSet)
            arr[j++] = i;
        return arr;
    }
}

使用Hash数组（针对元素个数有限）

使用hash1和hash2记录元素将对应位置置为1，对比hash1和hash2的元素同为1就将循环的索引加入创建的ArrayList，最后将可变长的List的元素存入新的数组中，并返回这个数组。

public int[] intersection(int[] nums1, int[] nums2) {
        int[] hash1 = new int[1002];
        int[] hash2 = new int[1002];
        for(int i : nums1)
            hash1[i]++;
        for(int i : nums2)
            hash2[i]++;
        List<Integer> resList = new ArrayList<>();
        for(int i = 0; i < 1002; i++)
            if(hash1[i] > 0 && hash2[i] > 0)
                resList.add(i);
        int index = 0;
        int res[] = new int[resList.size()];
        for(int i : resList)
            res[index++] = i;
        return res;
    }

202.快乐数

HashSet判断

class Solution {
    public boolean isHappy(int n) {
        if (n == 1)
            return true;
        Set<Integer> set1 = new HashSet<>();
        int cur = n;
        while (cur != 1) {
            int sum = 0;
            int last = -1;
            while (last != cur) {
                last = cur;
                int i = cur % 10;//获取个位
                sum += i * i;
                cur /= 10;
            }
            if (set1.contains(sum))
                return false;
            else {
                set1.add(sum);
                cur=sum;
            }
        }
        return true;
    }
}

1.判断两数之和

HashMap

通过key和value储存，key储存值，value储存索引

class Solution {
    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];   // 遍历当前元素，并在map中寻找是否有匹配的key
            if(map.containsKey(temp)){
                res[1] = i;
                res[0] = map.get(temp);
                break;
            }
            map.put(nums[i], i);    // 如果没找到匹配对，就把访问过的元素和下标加入到map中
        }
        return res;
    }
}