LeetCode分类习题-查找

查找

1. 查找表

这一部分主要考察各种数据结构的使用：

1. Set：元素互不重复，且只需要元素的值本身
2. HashMap：需要键值对存储，键不重复，无序
3. TreeMap：键值对存储，默认按键排序，也可自定义Comparator< E >
4. PriorityQueue：优先队列，用于无序输入、有序输出，例如任务调度场景，根据重要度返回队首

1.1 两个数组的交集（一）

重复结果只需要输出一次，因此只需要两个Set取交集

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();
        for (int num: nums1){
            set1.add(num);
        }
        for (int num: nums2){
            set2.add(num);
        }

        set1.retainAll(set2);

        int[] ans = new int[set1.size()];
        int idx = 0;
        for (int num: set1){
            ans[idx++] = num;
        }
        return ans;

    }
}

1.2 两个数组的交集（二）

重复元素输出次数以两个字符串中较小者为准，显然需要记录次数，用HashMap记录其中一个数组即可

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        Map<Integer, Integer> map1 = new HashMap<>();
        // 将nums1放进字典里
        for (int num: nums1){
            if (map1.containsKey(num)){
                map1.put(num, map1.get(num) + 1);
            }else{
                map1.put(num, 1);
            }
        }
        int[] ans = new int[nums1.length];
        int idx = 0;
        for (int num: nums2){
            if (map1.containsKey(num) && map1.get(num) > 0){
                ans[idx++] = num;
                map1.put(num, map1.get(num) - 1);
            }
        }
        return Arrays.copyOf(ans, idx);

    }
}

1.3 有效的字母异位词

两个字符串放进字典里，判断两个字典是否相等

class Solution {
    public boolean isAnagram(String s, String t) {
        Map<Character, Integer> map1 = new HashMap<>();
        Map<Character, Integer> map2 = new HashMap<>();
        for(int i = 0;i < s.length();i++){
            char c = s.charAt(i);
            if (map1.containsKey(c)){
                map1.put(c, map1.get(c) + 1);
            }else{
                map1.put(c, 1);
            }
        }
        for(int i = 0;i < t.length();i++){
            char c = t.charAt(i);
            if (map2.containsKey(c)){
                map2.put(c, map2.get(c) + 1);
            }else{
                map2.put(c, 1);
            }
        }

        return map1.equals(map2);

    }
}

1.4 快乐数

维护一个平方和变量sum，sum = 1就跳出循环，sum每次都放入Set中，如果sum重复出现Set中已有的数字，说明陷入无穷循环。

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        while (n != 1){
            int sum = 0;
            while (n > 0){
                int num = n % 10;
                sum += num*num;
                n /= 10;
            }
            if (set.contains(sum)){
                return false;
            }
            set.add(sum);
            n = sum;
        }
        return true;
    }
}

1.5 单词规律

将pattern和word分别put进map中，值为i，如果两个都是第一次放，或者之前放的次数相同，put的返回值也一定相同。

class Solution {
    public boolean wordPattern(String pattern, String str) {
        if (pattern == null && str == null) return true;
        if (pattern == null || str == null) return false;
        
        String[] values = str.split(" ");
        int n = values.length;
        if (pattern.length() != n) return false;
        Map<Object, Integer> map = new HashMap<>();
        for (int i = 0;i < n;i++){
            int x = map.put(pattern.charAt(i), i);
            int y = map.put(values[i], i);
            if (!Objects.equals(x, y)) return false;
        }
        return true;
    }
}

1.6 同构字符串

class Solution {
    public boolean isIsomorphic(String s, String t) {
        if (s.length() == 0 && t.length() == 0) return true;
        if (s.length() == 0 || t.length() == 0) return false;

        char[] c1 = s.toCharArray();
        char[] c2 = t.toCharArray();

        Map<Character, Character> map = new HashMap<>();
        for (int i = 0;i < c1.length;i++){
            if (map.containsKey(c1[i])){
                if (map.get(c1[i]) != c2[i]) return false;
            }else if (map.containsValue(c2[i])){
                return false;
            }else{
                map.put(c1[i], c2[i]);
            }
        }
        return true;
    }
}

1.7 根据字符出现频率排序

将给定字符串以字符为键频率为值传入一个map，再将map.entrySet()传入一个优先队列，最后不断返回队首的键值对并将键在输出字符串中重复值次。

class Solution {
    public String frequencySort(String s) {
        if (s.length() < 2) return s;
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0;i < s.length();i++){
            char x = s.charAt(i);
            if (map.containsKey(x)){
                map.put(x, map.get(x) + 1);
            }else{
                map.put(x, 1);
            }
        }

        Queue<Map.Entry<Character, Integer>> pq = new PriorityQueue<>(map.size(), 
        new Comparator<Map.Entry<Character, Integer>>(){
            @Override
            public int compare(Map.Entry<Character, Integer> e1, Map.Entry<Character, Integer> e2){
                return e2.getValue().compareTo(e1.getValue());
            }
        });

        for (Map.Entry<Character, Integer> entry: map.entrySet()){
            pq.add(entry);
        }

        StringBuilder ans = new StringBuilder();
        while(!pq.isEmpty()){
            Map.Entry<Character, Integer> entry = pq.poll();
            int num = entry.getValue();
            char c = entry.getKey();
            while(num > 0){
                ans.append(c);
                num--;
            }
        }

        return ans.toString();

    }
}