算法：哈希map相关题目

最新推荐文章于 2025-11-14 10:26:17 发布

原创最新推荐文章于 2025-11-14 10:26:17 发布 · 241 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#算法 #leetcode

算法专栏收录该内容

30 篇文章

订阅专栏

这篇博客探讨了如何利用哈希map解决算法问题，包括有效字母异位词的判断、字母异位词的分组以及两数之和的问题。通过比较不同解法，如暴力法与使用哈希map，展示了哈希map在提高算法效率上的优势。

哈希map相关题目

文章目录

哈希map相关题目

一、242. 有效的字母异位词

1.1 解法一：暴力，sort, nlogn

    public boolean isAnagram(String s, String t) {
        char[] sa = s.toCharArray();
        char[] ta = t.toCharArray();
        Arrays.sort(sa);
        Arrays.sort(ta);
        return Arrays.equals(sa, ta);
    }

1.2 解法二：使用map,或者长度为255 的数组

    public boolean isAnagram(String s, String t) {
        if (s.length()!=t.length()) return false;
        Map<Character, Integer> map = new HashMap<>();
        for (int i=0; i<s.length();i++) {
            Integer v = map.getOrDefault(s.charAt(i), 0);
            map.put(s.charAt(i), v+1);
        }
        for (int j=0; j<t.length(); j++) {
            map.put(t.charAt(j), map.getOrDefault(t.charAt(j),0)-1);
            if (map.get(t.charAt(j))<0) {
                return false;
            }
        }
        return true;
    }

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

二、49. 字母异位词分组

2.1 解法一：map

    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for (String str: strs) {
            char[] ca = str.toCharArray();
            Arrays.sort(ca);
            String key = new String(ca);
            List<String> list = map.getOrDefault(key, new ArrayList());
            list.add(str);
            map.put(key , list);
        }
        List<List<String>> result = new ArrayList<>();
        for (Map.Entry<String,List<String>> entry: map.entrySet()) {
            result.add(entry.getValue());
        }
        return result;
    }

优化：

    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for (String str: strs) {
            char[] ca = str.toCharArray();
            Arrays.sort(ca);
            String key = new String(ca);
            List<String> list = map.getOrDefault(key, new ArrayList());
            list.add(str);
            map.put(key , list);
        }
        /*List<List<String>> result = new ArrayList<>();
        for (Map.Entry<String,List<String>> entry: map.entrySet()) {
            result.add(entry.getValue());
        }*/
        return new ArrayList<>(map.values());
    }

使用数据来分组：

    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for (String str: strs) {
            int[] a = new int[26];
            for (int i=0; i<str.length(); i++) {
                a[str.charAt(i)-'a']++;
            }
            StringBuilder sb = new StringBuilder();
            for (int j=0; j<a.length; j++) {
                if (a[j]!=0) {
                    sb.append('a'+j);
                    sb.append(a[j]);
                }
            }
            List<String> list = map.getOrDefault(sb.toString(), new ArrayList<>());
            list.add(str);
            map.put(sb.toString(), list);
        }
        return new ArrayList<>(map.values());
    }

三、1. 两数之和

解法一：使用hash

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

解法二：暴力法

    public int[] twoSum(int[] nums, int target) {
        for (int i=0; i<nums.length-1; 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];
    }