【LC】HashMap和HashSet应用场景之OJ练习

苏黎世卡

已于 2023-03-20 22:41:51 修改

阅读量138

点赞数 5

分类专栏： LC/牛客-题解文章标签：数据结构链表 java leetcode Powered by 金山文档

于 2023-03-19 20:35:46 首次发布

本文链接：https://blog.csdn.net/weixin_56952690/article/details/129655285

版权

LC/牛客-题解专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1. 只出现一次的数字

💰OJ链接：136. 只出现一次的数字

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

说明：你的算法应该具有线性时间复杂度。你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1

示例 2:

输入: [4,1,2,1,2]
输出: 4

💯解题思路:

思路一：

直接使用异或，将数组中所有元素异或一遍，结果就是只出现一次的数字

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

思路二：

获取nums中的每个元素，直接往set中插入，如果插入失败，说明该元素已经存在，则将其删除掉。最后set中仅剩余的元素就是只出现一次的数据

public int singleNumber(int[] nums) {
        HashSet<Integer> set = new HashSet<>();
        for(int i = 0;i < nums.length;i++){
            if(!set.contains(nums[i])){
                set.add(nums[i]);
            }else{
                set.remove(nums[i]);
            }
        }
        for(int i = 0;i < nums.length;i++){
            if(set.contains(nums[i])){
                return nums[i];
            }
        }
        return -1;
}

2. 复制带随机指针的链表

💰OJ链接：138. 复制带随机指针的链表

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

构造这个链表的深拷贝。深拷贝应该正好由 n 个全新节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点。

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

val：一个表示 Node.val 的整数。

random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。

你的代码只接受原链表的头节点 head 作为传入参数。

示例 1：

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：

输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：

输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

💯解题思路:

思路一：

1. 依次获取原链表中的每个节点cur，创建值相等的newNode

将cur作为key，newNode作为value往新HashMap中插入

oldList：100--->200--->300--->400--->null

newList: 100 200 300 400

2. 处理新节点的next和random字段

m.get(cur)的返回值就是新节点

m.get(cur).next = m.get(cur.next);

m.get(cur).random = m.get(cur.random);

public Node copyRandomList(Node head) {
        if(null == head){
            return null;
        }
        // 1. 使用HashMap存储旧节点和新节点的映射
        Map<Node, Node> m = new HashMap<>();
        Node cur = head;
        while(null != cur){
            Node newNode = new Node(cur.val);
            m.put(cur, newNode);
            cur = cur.next;
        }
        // 2. 给新插入节点的随机引用字段赋值
        cur = head;
        while(null != cur){
            m.get(cur).next = m.get(cur.next);
            m.get(cur).random = m.get(cur.random);
            cur = cur.next;
        }
        return m.get(head);
    }

思路二：

1. 在原链表每个节点后插入值相等的新节点

2. 给新插入节点的随机指针域赋值

3. 将新插入节点从链表中拆下来

public Node copyRandomList1(Node head) {
        if(null == head){
            return null;
        }
        // 1. 在原链表每个新节点后插入值相等的新节点
        Node cur=head;
        while(null != cur){
            Node newNode = new Node(cur.val);
            // 将申请的新节点newNode插入到cur之后
            newNode.next = cur.next;
            cur.next = newNode;
            cur = newNode.next;
        }
        // 2. 给新插入节点的随机引用字段赋值
        // 新节点的随机引用字段指向 值相等的旧节点随机引用字段的下一个
        cur = head;
        while(null != cur)
        {
            //三个指针控制着random的连接
            Node newNode = cur.next;
            if(null != cur.random){
                newNode.random = cur.random.next;
            }
            cur = newNode.next;
        }
        //3. 将新插入节点从原链表中拆下来形成新链表
        cur = head;
        Node newhead = cur.next;
        while(null != cur.next){
            Node curNext = cur.next;
            cur.next = curNext.next;
            cur = curNext;
        }
        return newhead;
    }

3. 宝石与石头

💰OJ链接：771. 宝石与石头

给你一个字符串 jewels 代表石头中宝石的类型，另有一个字符串 stones 代表你拥有的石头。 stones 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。

字母区分大小写，因此 “a” 和 “A” 是不同类型的石头。

示例 1：

输入：jewels = "aA", stones = "aAAbbbb"
输出：3

示例 2：

输入：jewels = "z", stones = "ZZ"
输出：0

💯解题思路:

思路一：

1. 统计出S中每个石头出现的次数

2. 统计出J中每个保持在S中出现的次数之和也就是所有宝石的个数

public int numJewelsInStones(String J, String S) {
        // 借助Map统计S中每个字符出现的次数
        Map<Character, Integer> m = new TreeMap<>();
        for(int i = 0; i < S.length(); ++i){
            char ch = S.charAt(i);
            Integer val = m.get(ch);
            if(null != val){
                m.put(ch, val+1);
            }
            else{
                m.put(ch, 1);
            }
        }
        // 统计每个J中每个宝石种类出现的次数
        int count = 0;
        for(int i = 0; i < J.length(); ++i){
            char ch = J.charAt(i);
            Integer val = m.get(ch);
            if(null != val){
                count += val;
            }
        }
        return count;
    }

思路二：

将宝石 jewels 放入Set中，设置一个计数器 , 然后遍历石头stones 判断 jewels中是否含有stones 中的字符，含有则计数器++ .

public int numJewelsInStones(String jewels, String stones) {
        HashSet<Character> set = new HashSet<>();
        int size1 = jewels.length();
        int size2 = stones.length();
        int count = 0;
        //1.把宝石放在哈希Set中
        for(int i = 0;i < size1;i++){
            char ch = jewels.charAt(i);
            set.add(ch);
        }
        //2.遍历石头  set里有这个宝石  则次数++
        for(int i = 0;i < size2;i++){
            char ch = stones.charAt(i);
            if(set.contains(ch)){
                count++;
            }
        }
        return count;
    }

4. 旧键盘

💰OJ链接：旧键盘

旧键盘上坏了几个键，于是在敲一段文字的时候，对应的字符就不会出现。现在给出应该输入的一段文字、以及实际被输入的文字，请你列出肯定坏掉的那些键。

输入描述:

输入在2行中分别给出应该输入的文字、以及实际被输入的文字。每段文字是不超过80个字符的串，由字母A-Z（包括大、小写）、数字0-9、以及下划线“_”（代表空格）组成。题目保证2个字符串均非空。

输出描述:

按照发现顺序，在一行中输出坏掉的键。其中英文字母只输出大写，每个坏键只输出一次。题目保证至少有1个坏键。

输入 :

7_This_is_a_test
_hs_s_a_es

输出 :

7TI

💯解题思路:

对比应该输入的字符串和实际得到的字符串，如果应该输入字符串中的字母没有出现在实际得到的字符串中，则这些字母就是键盘中坏了的字母键。为了后序检测方便，在接收输入时统一将字符串全部转换为大写或者小写。

我们可将实际被输入的字符串添加到Set中，然后遍历应该输入的字符串，找到Set中不存在的字母，并输出这些字母，

由于应该输入的字符串中可能存在重复的字符，且要按顺序输出，我们可以采用一个辅助的集合Set用来查重，就是输出前判断这个集合中是否含有这个字符，如果含有则不输出，不含有则输出并将该元素放入辅助集合中。

import java.util.*;
// str1你需要输入的        str2实际输出的
public class Main {
    private static void func(String str1,String str2){
        HashSet<Character> set = new HashSet<>();
        for(char ch : str2.toUpperCase().toCharArray()){
            set.add(ch);
        }
        HashSet<Character> brokenSet = new HashSet<>();
        for(char ch : str1.toUpperCase().toCharArray()){
            if(!set.contains(ch) && !brokenSet.contains(ch)){
                brokenSet.add(ch);
                System.out.print(ch);
            }
        }
    } 
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        while(scan.hasNextLine()){
            String str1 = scan.nextLine();
            String str2 = scan.nextLine();
            func(str1,str2);
        }
    }
}

5. 前K个高频单词

💰OJ链接：692. 前K个高频单词

给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。

返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率，按字典顺序排序。

示例 1：

输入: words = ["i", "love", "leetcode", "i", "love", "coding"], k = 2
输出: ["i", "love"]
解析: "i" 和 "love" 为出现次数最多的两个单词，均为2次。
注意，按字母顺序 "i" 在 "love" 之前。

示例 2：

输入: ["the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"], k = 4
输出: ["the", "is", "sunny", "day"]
解析: "the", "is", "sunny" 和 "day" 是出现次数最多的四个单词，
出现次数依次为 4, 3, 2 和 1 次。

💯解题思路:

TOP-K问题:前k个最大，创建小堆

前k个最小，创建大堆

1. 借助Map统计每个单词出现的次数

2. 用Map中前k个元素(键值对)构建一个小堆

3. 用剩余的元素依次和堆顶元素进行比较，如果比堆顶元素大，替换堆顶元素

4. 将堆中的元素保存到List中，再进行逆置(因为是小堆，结果不符合题目要求)

比较器规则：

1. 如果用o1 - o2，创建的就是小堆

2. 如果用o2 - o1，创建的就是大堆

class Solution {
    public static List<String> topKFrequent(String[] words, int k) {
        int size = words.length;
        HashMap<String,Integer> map = new HashMap<>();
        for (String s : words) {
            if (map.get(s) == null) {
                map.put(s, 1);
            } else {
                Integer val = map.get(s);
                map.put(s, val + 1);
            }
        }
        //单词的次数已经统计好了
        //2.遍历map中的entry，建立大小为k的小根堆。
        PriorityQueue<Map.Entry<String,Integer>> minHeap = new PriorityQueue<>(k, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                if(o1.getValue().compareTo(o2.getValue()) == 0){
                    return o2.getKey().compareTo(o1.getKey());
                }
                return o1.getValue().compareTo(o2.getValue());
            }
        });
        //3.遍历map每个Entry
        for (Map.Entry<String,Integer> entry:
             map.entrySet()) {
            if(minHeap.size() < k){
                minHeap.offer(entry);
            } else {
                Map.Entry<String,Integer> top = minHeap.peek();
                //出堆
                if(entry.getValue().compareTo(top.getValue()) > 0){
                    minHeap.poll();
                    minHeap.offer(entry);
                }else{ //频率相同了处理  小的不用处理
                    //频率相同
                    if(entry.getValue().compareTo(top.getValue()) == 0){
                        //判断 字符 大小  字符小就  放进去
                        if(top.getKey().compareTo(entry.getKey()) > 0){
                            minHeap.poll();
                            minHeap.offer(entry);   
                        }
                    }
                }
            }
        }
        //  取堆中的前K个元素
        List<String> list = new ArrayList<>();
        for(int i = 0; i < k;i++){
            Map.Entry<String,Integer> top = minHeap.poll();
            list.add(top.getKey());
        }
        // 注意：从优先级队列中取出的元素刚好是反的，需要逆置过来
        Collections.reverse(list);
        return list;
    }
    public static void main(String[] args) {
        String[] words = {"the", "day", "is", "sunny", "the", "the", "the", "sunny", "is", "is"};
        List<String> list = topKFrequent(words,4);
        System.out.println(list);
    }
}

6. 存在重复元素 II

💰OJ链接：219存在重复元素 II

给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [1,2,3,1], k = 3
输出：true

示例 2：

输入：nums = [1,0,1,1], k = 1
输出：true

示例 3：

输入：nums = [1,2,3,1,2,3], k = 2
输出：false

💯解题思路:

1. 将nums中元素作为key，元素对应的下标作为value往map中插入

2. 如果nums[i]已经存在了，就与之前的下标进行相减，结果小于k是返回true

3. 循环结束后方法没有退出，说明不存在直接返回false

public boolean containsNearbyDuplicate(int[] nums, int k) {
        Map<Integer, Integer> m = new HashMap<>();
        // 将nums中元素作为key，元素对应的下标作为value
        for(int i = 0; i < nums.length; ++i){
            if(m.containsKey(nums[i])){
                // 如果nums[i]在map中出现了，再计算下标差
                if(i - m.get(nums[i]) <= k){
                    return true;
                }
            }
            // 如果不存在，插入该键值对
            // 或者更新下标
            m.put(nums[i], i);
        }
        return false;
    }