集合及数据结构第十二节（下）————哈希表、字符串常量池和练习题

系列文章目录

集合及数据结构第十二节（下）————哈希表、字符串常量池和练习题

哈希表、字符串常量池和练习题

哈希表的概念
冲突-概念
冲突-避免
冲突-解决
冲突严重时的解决办法
冲突严重时的解决办法的实现
性能分析
和 java 类集的关系
Hashmap的使用案例
模拟实现HashMap（k-v模型）
创建对象的思考
字符串常量池(StringTable)
再谈String对象创建
练习

文章目录

系列文章目录
- 集合及数据结构第十二节（下）————哈希表、字符串常量池和练习题
一、哈希表
- 1.哈希表的概念
- 2.冲突-概念
- 3.冲突-避免
- - 1 冲突-避免-哈希函数设计
  - 2 冲突-避免-负载因子调节（重点掌握）（ * * * ）
- 4.冲突-解决
- - 1 冲突-解决-闭散列（ * * * ）
  - 2 冲突-解决-开散列/哈希桶（重点掌握）（ * * ）
- 5.冲突严重时的解决办法
- 6.实现
- 7.性能分析
- 8.和 java 类集的关系
- 9.Hashmap的使用案例
- - 如何把一个对象转换成一个整数（hashcode方法）
三、模拟实现HashMap（k-v模型）
- - 属性
  - put方法
  - get方法
四、字符串常量池
- 1.创建对象的思考
- 2.字符串常量池(StringTable)
- 3.再谈String对象创建
- - 1. 直接使用字符串常量进行赋值
  - 2. 通过new创建String类对象
  - 3. intern方法
五、练习
- 1.只出现一次的数字
- 2.复制带随机指针的链表（ * * * ）
- - 思路
- 3. 宝石与石头（ * * ）
- 4.坏键盘打字
- 5.前K个高频单词（ * * * ）

一、哈希表

1.哈希表的概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(log2 N )，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

当向该结构中：

插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)
例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。

在这里插入图片描述

2.冲突-概念

用之前的方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快 问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？

对于两个数据元素的关键字和 (i != j)，有 != ，但有：Hash( ) == Hash( )，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞
把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。
在这里插入图片描述

3.冲突-避免

首先，需要明确一点，由于哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，因此能做的应该是尽量的降低冲突率。

1 冲突-避免-哈希函数设计

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。哈希函数设计原则：

哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
哈希函数计算出来的地址能均匀分布在整个空间中
哈希函数应该比较简单

常见哈希函数

直接定制法–(常用)
取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀缺点：需要事先知道关键字的分布情况使用场景：适合查找比较小且连续的情况
例如：字符串中第一个只出现一次字符
除留余数法–(常用)
设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址
平方取中法–(了解)
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
折叠法–(了解)
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。

折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况。

随机数法–(了解)
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。

通常应用于关键字长度不等时采用此法

数学分析法–(了解)
设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：

假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方
法。

数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况。

注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

2 冲突-避免-负载因子调节（重点掌握）（ * * * ）

在这里插入图片描述

负载因子和冲突率的关系粗略演示
在这里插入图片描述
所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。
已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小

4.冲突-解决

解决哈希冲突两种常见的方法是：闭散列和开散列

1 冲突-解决-闭散列（ * * * ）

**闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去。**那如何寻找下一个空位置呢？

线性探测
比如上面的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，下标为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。
线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。

插入

通过哈希函数获取待插入元素在哈希表中的位置
如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲 - 突，使用线性探测找到
下一个空位置，插入新元素

在这里插入图片描述

采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。

二次探测
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： = ( + )% m, 或者：= ( - )% m。其中：i = 1,2,3…，是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。对于2.1中如果要插入44，产生冲突，使用解决后的情况为：

在这里插入图片描述

研究表明：当表的长度为质数且表装载因子a不超过0.5时，新的表项一定能够插入，而且任何一个位置都不会被探查两次。因此只要表中有一半的空位置，就不会存在表满的问题。在搜索时可以不考虑表装满的情况，但在插入时必须确保表的装载因子a不超过0.5，如果超出必须考虑增容。
因此：比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

2 冲突-解决-开散列/哈希桶（重点掌握）（ * * ）

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中.

在这里插入图片描述

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。
开散列，可以认为是把一个在大集合中的搜索问题转化为在小集合中做搜索了。

5.冲突严重时的解决办法

刚才我们提到了，哈希桶其实可以看作将大集合的搜索问题转化为小集合的搜索问题了，那如果冲突严重，就意味着小集合的搜索性能其实也时不佳的，这个时候我们就可以将这个所谓的小集合搜索问题继续进行转化，例如：

每个桶的背后是另一个哈希表
每个桶的背后是一棵搜索树

6.实现

public class HushBuck {
    static class Node{//链表节点
        public  int key;
        public  int val;
        public Node next;

        public Node(int key, int val) {//构造方法
            this.key = key;
            this.val = val;
        }
    }
    public Node[] array;//桶
    public  int usedSize;//存放了多少数据
    public static final float DEFAULT_LOAD_FACTOR = 0.75f;//负载因子
    public HushBuck(){//构造方法
        array =  new Node[10];
    }

    public void put(int key,int val){
        int index = key % array.length;//确定key要放的位置

        //遍历index下标的链表，并查看是否存在key，如果存在就更新value，不存在就进行插入数据
        Node cur = array[index];
        while (cur != null){//遍历array
            if (cur.key == key){//如果cur的key等于key
                cur.val = val;//更新val
            }
            cur = cur.next;//继续向后查找
        }
        //链表遍历结束，没有找到这个key，头插法插入这个数据
        Node node = new Node(key,val);
        node.next = array[index];
        array[index] = node;
        usedSize++;
        if(doLoadFactor() > DEFAULT_LOAD_FACTOR){//负载因子超过默认值,进行扩容。
            //要进行重新哈希，因为长度变了，原来位置冲突的位置可能要放到新的数组的其他位置去
            resize();
        }
    }
    private void resize(){
        Node[] newArray = new Node[2 * array.length];

        for (int i = 0; i <array.length; i++) {
            Node cur  = array[i];
            while (cur != null){//遍历原来哈希数组的每个数组元素
                Node temp  = cur.next;
                int  newIndex = cur.key % newArray.length;//获取新的数组下标
                //采用头插法插入到新数组的newIndex下标
                cur.next = newArray[newIndex];
                newArray[newIndex] = cur;
                cur = temp;//向后移动
            }
        }
        array = newArray;
    }
    private  float doLoadFactor(){//计算负载因子有没有超过默认值
        return  usedSize * 1.0f / array.length;
    }
    public  int get (int key){
        int index = key % array.length;//确定key要放的位置
        Node cur = array[index];
        while (cur != null){//遍历array
            if (cur.key == key){//如果cur的key等于key
               return cur.val;//返回cur的val
            }
            cur = cur.next;//继续向后查找
        }
        return  -1;//循环结束还没有找到，返回-1
    }
}

7.性能分析

虽然哈希表一直在和冲突做斗争，但在实际使用过程中，我们认为哈希表的冲突率是不高的，冲突个数是可控的，也就是每个桶中的链表的长度是一个常数，所以，通常意义下，我们认为哈希表的插入/删除/查找时间复杂度是O(1)

8.和 java 类集的关系

HashMap 和 HashSet 即 java 中利用哈希表实现的 Map 和 Set
java 中使用的是哈希桶方式解决冲突的
java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）
java 中计算哈希值实际上是调用的类的 hashCode 方法，进行 key 的相等性比较是调用 key 的 equals 方法。所以如果要用自定义类作为 HashMap 的 key 或者 HashSet 的值，必须覆写 hashCode 和 equals 方法，而且要做到 equals 相等的对象，hashCode 一定是一致的

9.Hashmap的使用案例

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

class Student{

}
public class Test {
    public static void main(String[] args) {
        HashMap<String,Integer> map = new HashMap<>();
        map.put("晴天",6);
        map.put("雨天",3);
        map.put("阴天",1);

        Integer val = map.get("阴天");
        System.out.println(val);

        System.out.println(map);//第一种遍历map的方式

        for (Map.Entry<String,Integer> entry :map.entrySet()){//第二种遍历map的方式
            System.out.println("key" + entry.getKey() + "value" + entry.getValue());
        }

        //HashMap不支持迭代器遍历

        HashMap<Student,Integer> map2 = new HashMap<>();
        map2.put(new Student(),2);//HashMap中不会根据k（new Student()）来进行大小比较，所有只有在TreeMap中回报类型转换异常
        map2.put(null,3);//在HashMap中只是把它放到了指定位置，不会出现空指针异常

        HashSet<String> set = new HashSet<>();

        //set中不能存储相同的key，是可以天然去重的
        //set的底层是一个HashMap，每次存储元素的的时候，默认的value其实就是一个Object对象
        set.add("ni");
        set.add("ni");
        set.add("xio");
        set.add("xp");
        System.out.println(set);
    }
}

在这里插入图片描述

如何把一个对象转换成一个整数（hashcode方法）

import java.util.*;

class Student{
    public String id;

    public Student(String id) {
        this.id = id;
    }
}

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("41154445");
        Student student2 = new Student("41154445");

        System.out.println(student1.hashCode());//调用object默认的hashCode方法时，打印结果不一样
        System.out.println(student2.hashCode());
    }

在这里插入图片描述

import java.util.*;

class Student{
    public String id;

    public Student(String id) {
        this.id = id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(id, student.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("41154445");
        Student student2 = new Student("41154445");



        HashMap<Student,Integer> map  = new HashMap<>();
        map.put(student1,2);
        System.out.println(map.get(student2));//只有在重写了hashcode后才会找到2
    }

在这里插入图片描述
在写一个自定义类型的时候，最好把equals方法和hashCode方法都重写一下

三、模拟实现HashMap（k-v模型）

属性

public class MyHashBuck<K,V> {
    static class Node<K,V>{
        public K key;
        public V value;
        public Node<K,V> next;

        public Node(K key, V value){//构造方法
            this.key = key;
            this.value = value;
        }
    }
        public Node<K,V>[] array;
        public int usedSize;//存放了多少数据
        public static final float DEFAULT_LOAD_FACTOR = 0.75f;//负载因子

        public  MyHashBuck(){//构造方法
            array = (Node<K, V>[])new Node[10];
        }
}

put方法

public void put(K key,V value){
            int hash = key.hashCode();
            int index = hash % array.length;//处理完后变成哈希表中合法的下标
            //遍历index下标的链表，并查看是否存在key，如果存在就更新value，不存在就进行插入数据
            Node<K,V> cur = array[index];
            while (cur != null){//遍历array
                if (cur.key.equals(key)){//如果cur的key等于key
                    cur.value = value;//更新val
                    return;
                }
                cur = cur.next;//继续向后查找
            }
            //链表遍历结束，没有找到这个key，头插法插入这个数据
            Node<K,V> node = new Node(key,value);
            node.next = array[index];
            array[index] = node;
            usedSize++;
        }

get方法

 public V getValue(K key){
            int hash = key.hashCode();
            int index = hash % array.length;//处理完后变成哈希表中合法的下标
            //遍历index下标的链表，并查看是否存在key，如果存在就更新value，不存在就进行插入数据
            Node<K,V> cur = array[index];
            while (cur != null){//遍历array
                if (cur.key.equals(key)){//如果cur的key等于key
                 return  cur.value;//返回cur的value
                }
                cur = cur.next;//继续向后查找
            }
            return null;//循环结束还没有找到，说明没有，返回null
        }

完整代码

public class MyHashBuck<K,V> {
    static class Node<K,V>{
        public K key;
        public V value;
        public Node<K,V> next;

        public Node(K key, V value){//构造方法
            this.key = key;
            this.value = value;
        }
    }
        public Node<K,V>[] array;
        public int usedSize;//存放了多少数据
        public static final float DEFAULT_LOAD_FACTOR = 0.75f;//负载因子

        public  MyHashBuck(){//构造方法
            array = (Node<K, V>[])new Node[10];
        }

        public void put(K key,V value){
            int hash = key.hashCode();
            int index = hash % array.length;//处理完后变成哈希表中合法的下标
            //遍历index下标的链表，并查看是否存在key，如果存在就更新value，不存在就进行插入数据
            Node<K,V> cur = array[index];
            while (cur != null){//遍历array
                if (cur.key.equals(key)){//如果cur的key等于key
                    cur.value = value;//更新val
                    return;
                }
                cur = cur.next;//继续向后查找
            }
            //链表遍历结束，没有找到这个key，头插法插入这个数据
            Node<K,V> node = new Node(key,value);
            node.next = array[index];
            array[index] = node;
            usedSize++;
        }
        public V getValue(K key){
            int hash = key.hashCode();
            int index = hash % array.length;//处理完后变成哈希表中合法的下标
            //遍历index下标的链表，并查看是否存在key，如果存在就更新value，不存在就进行插入数据
            Node<K,V> cur = array[index];
            while (cur != null){//遍历array
                if (cur.key.equals(key)){//如果cur的key等于key
                 return  cur.value;//返回cur的value
                }
                cur = cur.next;//继续向后查找
            }
            return null;//循环结束还没有找到，说明没有，返回null
        }

}

测试：

import java.util.Objects;

class Students{
    public String id;

    public Students(String id) {
        this.id = id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Students students = (Students) o;
        return Objects.equals(id, students.id);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}
public class Test  {
    public static void main(String[] args) {
        Student student1 = new Student("61054445");
        Student student2 = new Student("61054445");
        MyHashBuck<Student,Integer> myHashBuck = new MyHashBuck<>();
        myHashBuck.put(student1,10);
        Integer val = myHashBuck.getValue(student2);
        System.out.println(val);
    }

}

在这里插入图片描述

四、字符串常量池

1.创建对象的思考

下面两种创建String对象的方式相同吗？

public static void main(String[] args) {
	String s1 = "hello";
	String s2 = "hello";
	String s3 = new String("hello");
	String s4 = new String("hello");
	System.out.println(s1 == s2); // true
	System.out.println(s1 == s3); // false
	System.out.println(s3 == s4); // false
}

在这里插入图片描述

上述程序创建方式类似，为什么s1和s2引用的是同一个对象，而s3和s4不是呢？
在Java程序中，类似于：1， 2， 3，3.14，“hello”等字面类型的常量经常频繁使用，为了使程序的运行速度更快、更节省内存，Java为8种基本数据类型和String类都提供了常量池.

“池” 是编程中的一种常见的, 重要的提升效率的方式, 我们会在未来的学习中遇到各种 “内存池”, “线程池”, “数据库连接池”
… 比如：家里给大家打生活费的方式

家里经济拮据，每月定时打生活费，有时可能会晚，最差情况下可能需要向家里张口要，速度慢
家里有矿，一次性打一年的生活费放到银行卡中，自己随用随取，速度非常快方式2，就是池化技术的一种示例，钱放在卡上，随用随取，效率非常高。常见的池化技术比如：数据库连接池、线程池等

为了节省存储空间以及程序的运行效率，Java中引入了：

Class文件常量池：每个.Java源文件编译后生成.Class文件中会保存当前类中的字面常量以及符号信息
运行时常量池：在.Class文件被加载时，.Class文件中的常量池被加载到内存中称为运行时常量池，运行时常
量池每个类都有一份
字符串常量池

2.字符串常量池(StringTable)

字符串常量池在JVM中是StringTable类，实际是一个固定大小的HashTable(一种高效用来进行查找的数据结构)，不同JDK版本下字符串常量池的位置以及默认大小是不同的：

在这里插入图片描述

3.再谈String对象创建

由于不同JDK版本对字符串常量池的处理方式不同，此处在Java8 HotSpot上分析

1. 直接使用字符串常量进行赋值

public static void main(String[] args) {
	String s1 = "hello";
	String s2 = "hello";
	System.out.println(s1 == s2); // true
}

在这里插入图片描述

2. 通过new创建String类对象

在这里插入图片描述
结论：只要是new的对象，都是唯一的。
通过上面例子可以看出：使用常量串创建String类型对象的效率更高，而且更节省空间。用户也可以将创建的
字符串对象通过 intern 方式添加进字符串常量池中。

3. intern方法

intern 是一个native方法(Native方法指：底层使用C++实现的，看不到其实现的源代码)，该方法的作用是手动将创建的String对象添加到常量池中

public static void main(String[] args) {
	char[] ch = new char[]{'a', 'b', 'c'};
	String s1 = new String(ch); // s1对象并不在常量池中
	//s1.intern(); // s1.intern()；调用之后，会将s1对象的引用放入到常量池中
	String s2 = "abc"; // "abc" 在常量池中存在了，s2创建时直接用常量池中"abc"的引用
	System.out.println(s1 == s2);
} 
// 输出false
// 将上述方法打开之后，就会输出true

在这里插入图片描述

注意：在Java6 和 Java7、8中Intern的实现会有些许的差别

五、练习

1.只出现一次的数字

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

你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

示例 1 ：

输入：nums = [2,2,1]
输出：1
示例 2 ：

输入：nums = [4,1,2,1,2]
输出：4
示例 3 ：

输入：nums = [1]
输出：1

class Solution {
      public int singleNumber(int[] nums) {//只出现一次的数字
        HashSet<Integer> set = new HashSet<>();
        for (int x : nums){//for循环遍历nums
            if (!set.contains(x)){//如果nums不存在x
                set.add(x);//将x放进set中
            }else {//如果nums存在x
                set.remove(x);//删除set中的x
            }
        }
        //现在集合中只有一个元素了
        for (int x : nums){//for循环遍历nums
            if (set.contains(x)){//如果nums不存在x
                return x;//找到了这个元素，直接返回
            }       
        }
         return -1;//没有，说明没有只出现过一次的元素，返回-1
    }
}

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

给你一个长度为 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]]

思路

在这里插入图片描述
代码实现

class Solution {
       public Node copyRandomList(Node head) {// 随机链表的复制
        Map<Node,Node> map = new HashMap<>();
        Node cur = head;
        while (cur != null){//1. 从头开始遍历链表,存储对应关系
            Node node = new Node(cur.val);//每次实例化一个新的结点
            map.put(cur,node);//将老节点放进key 新节点放进value
            cur = cur.next;
        }
        //2. 遍历链表，修改新节点的指向
        cur = head;//cur重新指向头
        while (cur != null){
            map.get(cur).next = map.get(cur.next);//修改新节点的next
            map.get(cur).random = map.get(cur.random);//修改新节点的random
            cur = cur.next;//向后移动
        }
        return  map.get(head);//返回新节点的第一个（老家的头节点所指向的节点在map中的value）
    } 
}

3. 宝石与石头（ * * ）

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

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

示例 1：

输入：jewels = “aA”, stones = “aAAbbbb”
输出：3
示例 2：

输入：jewels = “z”, stones = “ZZ”
输出：0

class Solution {
    public int numJewelsInStones(String jewels, String stones) {
        HashSet<Character> set = new HashSet<>();
        for(char ch : jewels.toCharArray()){//遍历jewels字符串
            set.add(ch);//将宝石放进set
        }
        int count = 0;//用来统计宝石的数量
        for(char ch : stones.toCharArray()){//遍历stones字符串
            if(set.contains(ch)){//
                count++;//当stones字符串中有ser中的元素时，说明是宝石
            }
        }
        return count;
    }
}

4.坏键盘打字

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

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

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

示例1

输入

7_This_is_a_test
_hs_s_a_es

输出

7TI

import java.util.*;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String str1 = in.nextLine();
            String str2 = in.nextLine();
            func(str1, str2);
        }
    }
    private static void func(String str1, String str2) {
        HashSet<Character> set = new HashSet<>();
        for (char ch : str2.toUpperCase().toCharArray()) { //遍历str2(转换为大小)
            set.add(ch);//将str2存进set
        }

        HashSet<Character> setBreak = new HashSet<>();//存放坏的键位
        for (char ch : str1.toUpperCase().toCharArray()) { //遍历str1(转换为大小)
            if (!set.contains(ch) &&
                    !setBreak.contains(ch)) {//如果str1中不包含set中的元素并且还没有存进setBreak(坏了的键位）
                System.out.print(ch);//打印坏了的键位
                setBreak.add(ch);//存进setBreak中避免坏的键位重复打印
            }
        }
    }
}

5.前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 次。

代码实现：

class Solution {
          public List<String> topKFrequent(String[] words, int k) {//前K个高频单词
        //1. 先遍历数组，统计单词出现的次数
        Map<String,Integer> map = new HashMap<>();//用map来确定每个单词出现的次数
        for (String word: words){
            if (map.get(word) == null){//此时map中没有这个单词
                map.put(word,1);//存进map并计数1
            }else {//此时map中有这个单词
                int value = map.get(word);
                map.put(word,value + 1);//统计次数加一
            }
        }
        //2.遍历统计好的map,把每组数据存储到小根堆中
        PriorityQueue<Map.Entry<String,Integer>> minHeap = new PriorityQueue<>(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){//5. 放元素的时候如果频率相同，转变为大根堆，按照单词的字典序排序
                    return o2.getKey().compareTo(o1.getKey());
                }
                return o1.getValue().compareTo(o2.getValue());
            }
        });
        for (Map.Entry<String,Integer> entry: map.entrySet()){//遍历map，将统计好的数据放进小根堆中
            if (minHeap.size() < k){//小根堆没有放满
                minHeap.offer(entry);
            }else {//小根堆放满了
                Map.Entry<String,Integer> top = minHeap.peek();//查看堆顶元素
                if (top.getValue().compareTo(entry.getValue()) < 0){//如果堆顶元素的频率小于当前放的元素的频率
                    minHeap.poll();//出栈顶元素
                    minHeap.offer(entry);//当前元素入堆
                }else {//如果堆顶元素的频率大于当前放的元素的频率
                    if (top.getValue() == entry.getValue()){//如果堆顶元素的频率等于当前放的元素的频率
                        if (top.getKey().compareTo(entry.getKey()  )> 0){//按照字典顺序排序
                            minHeap.poll();//出栈顶元素
                            minHeap.offer(entry);//当前元素入堆
                        }
                    }
                }
            }
        }
        //根据频率大小放到了小根堆
        List<String> ret =  new ArrayList<>();
        for (int i = 0; i < k; i++) {//3.for循环遍历小根堆并将其存进List中
            Map.Entry<String,Integer> top = minHeap.poll();//弹出堆顶元素并获取
            ret.add(top.getKey());//将频率大的k个元素从小到大放进ret
        }
        //4.逆置ret
        Collections.reverse(ret);
        return ret;
    }
}