编程题汇总_Map和Set

1.只出现一次的数字

题目链接：只出现一次的数字

程序测试：利用Map

核心思路：利用Map记录每个数字出现的次数。

  public int singleNumber(int[] nums) {
        // 统计每个数字出现的次数
        Map<Integer,Integer> map = new HashMap<>();
        for(int num:nums){
            int n = map.getOrDefault(num,0);
            map.put(num,++n);
        }
        int k  = 0;
        // 遍历 map, 找到 出现次数 为 1 次的 数字
        for(Map.Entry<Integer,Integer> entry:map.entrySet()){
           // getValue 得到的是 Integer 包装类. 
           // 通过 equals 判定相当于对 1 进行自动装箱, 比较两个 Integer 的值
           // 如果写成 == 1, 相当有对 Integer 自动拆箱, 比较两个 ==
            if(entry.getValue() == 1){
                k = entry.getKey();
                break;
            }
        }
        return k;
    }

注意：
1.entry.getValue() 得到的是 Integer 包装类. 通过 equals 判定相当于对 1 进行自动装箱, 比较两个 Integer 的值。
2.如果写成 entry.getValue() == 1, 相当有对 Integer 自动拆箱, 比较两个 ==。
3.for each 底层也是依靠迭代器来实现的。

程序测试：按位异或

核心思路：通过异或规则（相同为0，相异为1）

  public int singleNumber(int[] nums) {
        int ret = 0;
        for (int x : nums) {
            ret ^= x;
        }
        return ret;
    }

升级版：只出现一次的数字

题目描述：给定一个非空整数数组，除了某两个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的两个元素。

思路解析：

注意：下面的程序只能保证输出的两个数字一定是只出现一次的数字，但不保证先后顺序已一定一致。（例如上面的举例输出5 4）

  public int[] singleNumber2(int[] nums) {
        // 1. 先把所有数字异或到一起
        int ret = 0;
        for (int x : nums) {
            ret ^= x;
        }
        // 2. 此时的异或结果相当于 a ^ b, 值一定不为 0. 就可以从中找到某个为 1 的 bit 位
        int bit = 1;
        int i = 0;
        for (; i < 32; i++) {
            if ((ret & (bit << i)) != 0) {
                break;
            }
        }
        // 循环结束之后, bit 中的值, 就是刚找到某一位为 1 的值
        // 进行分组
        int a = 0;
        int b = 0;
        for (int x : nums) {
            if ((x & (bit << i)) != 0) {
                // 第一组, 指定位为 1
                a ^= x;
            } else {
                // 第二组, 指定位为 0
                b ^= x;
            }
        }
        int[] array = {a, b};
        return array;
    }

eg：int[] nums = {1,1,2,2,4,5}; //异或结果ret = 0001，第0位是1即i = 0
分组操作能保证两点：让a和b分散到不同组；让值相同的元素一定子同一组。

2.坏键盘打字

题目链接：坏键盘打字

程序测试：利用Set

import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;

public class BrokenKeyboard {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String right = scanner.nextLine();
        String wrong = scanner.nextLine();

        Set<Character> set = new TreeSet<>();
        for (char c : wrong.toCharArray()) {
            set.add(c);
        }

        Set<Character> written = new TreeSet<>();
        for (char c : right.toCharArray()) {
            if (!set.contains(c)) { //错误输出不包含c c为坏键盘
                c = Character.toUpperCase(c); //c转换为大写
                if (!written.contains(c)) { //written中不包含c 打印c并写入c
                    System.out.print(c); //必须用print() 单行打印
                    written.add(c);
                }
            }
        }
        System.out.println();
    }
}

测试结果：

注意：
1> c = Character.toUpperCase( c ); //字符c转大写
2> System.out.print©; //必须用print() 结果要单行打印

3.前K个高频单词

题目链接**：前K个高频单词

程序测试：利用Map和Set

import java.util.*;

public class TopK {
    public static Map<String, Integer> calcCount(String[] words) {
        Map<String, Integer> map = new HashMap<>();
        //单词--次数
        for (String w : words) {
            int count = map.getOrDefault(w, 0);
            //V getOrDefault(Object key, V defaultValue)    返回key对应的value，key不存在，返回默认值
            map.put(w, count + 1); //V put(K key, V value)   设置key对应的value
        }

        return map;
    }

    //次数--单词
    public static Map<Integer, List<String>> calcCountOfWords(Map<String, Integer> map) {
        Map<Integer, List<String>> ret = new HashMap<>();
        for (Map.Entry<String, Integer> e : map.entrySet()) { //Set<Map.Entry<K, V>> entrySet() 返回所有的key-value映射关系
            String word = e.getKey(); //K getKey()    返回entry中的 key
            int count = e.getValue(); //V getValue()    返回entry中的 value

            if (!ret.containsKey(count)) {
                ret.put(count, new ArrayList<>());
            }
            ret.get(count).add(word); //ret.get(count)得到的是List
        }

        return ret;
    }

    private static class IntegerComparator implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2 - o1;
        }
    }

    public static void main(String[] args) {
        String[] words = {"the", "day", "is", "sunny", "is", "the", "the", "the", "sunny", "is", "is","love","love"};
        int k = 3;
        Map<String, Integer> wordCount = calcCount(words);
        System.out.println("单词--次数："+wordCount);
        Map<Integer, List<String>> countToWordList = calcCountOfWords(wordCount);
        System.out.println("次数--单词："+countToWordList);

        Set<Integer> counts = countToWordList.keySet();
        System.out.println("次数："+counts);
        List<Integer> countsList = new ArrayList<>(counts); //转List类型
        Collections.sort(countsList, new IntegerComparator()); //因为Sort默认排序升序 想要降序传入比较器
        System.out.println("次数排序："+countsList);
        /*
        Collections.sort(countsList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
         */
        //Collections.sort(countsList, (o1, o2) -> o2 - o1);

        //打印前K个高频字符
        List<String> result = new ArrayList<>();
        int n = 0;
        int i = 0;
        while (n < k) {
            int count = countsList.get(i);
            i++;
            List<String> ws = countToWordList.get(count);
            Collections.sort(ws);
            if (ws.size() <= k - n) {
                // 如果候选人数量小于需要人数，全部录取
                result.addAll(ws);
                n += ws.size();
            } else {
                // 否则，只录取需要的人数
                result.addAll(ws.subList(0, k - n));
                n += (k - n);
            }
        }
        System.out.println("打印前K个单词"+result);
    }
}

测试结果：

注意：
1> Collections.sort(countsList, new IntegerComparator()); //因为Sort默认排序升序 想要降序需传入比较器

2>排序（匿名类–只用一次）

//定义了一个新的类 这个类是Comparator的一个子类 这个类没有名字 直接new了一个对象传进去
Collections.sort(countsList, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        })

3> Collections.sort(countsList, (o1, o2) -> o2 - o1); //排序可以直接这么写