一，set和map
Map和 set 是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。 一般把搜索的数据称为关键字（ Key ），和关键字对应的称为值（ Value ），将其称之为 Key-value 的键值对，所以 模型会有两种： 1. 纯 key 模型 ，比如：
有一个英文词典，快速查找一个单词是否在词典中
快速查找某个名字在不在通讯录中
2. Key-Value 模型 ，比如：
统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数： < 单词，单词出现的次数 >
梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号
Map 中存储的就是 key-value 的键值对， Set 中只存储了 Key（ K 一定是唯一的，不 能重复 ）
二，方法展示
2.1 set常见方法
|---------------------------------------------|---------------------------------------------|
| boolean add (E e) | 添加元素，但重复元素不会被添加成功 |
| void clear () | 清空集合 |
| boolean contains (Object o) | 判断 o 是否在集合中 |
| Iterator<E> iterator () | 返回迭代器 |
| boolean remove (Object o) | 删除集合中的 o |
| int size() | 返回 set 中元素的个数 |
| boolean isEmpty() | 检测 set 是否为空，空返回 true ，否则返回 false |
| Object[] toArray() | 将 set 中的元素转换为数组返回 |
| boolean containsAll(Collection<?> c) | 集合 c 中的元素是否在 set 中全部存在，是返回 true ，否则返回 false |
| boolean addAll(Collection<? extends E> c) | 将集合 c 中的元素添加到 set 中，可以达到去重的效果 |
注意：
1.Set 是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeSet或者HashSet等
2. Set 中只存储了 key ，并且要求 key一定要唯一
3. TreeSet 的底层是使用 Map 来实现的，其使用 key 与 Object 的一个默认对象作为键值对插入到 Map 中的
4. Set 最大的功能 就是对集合中的元素进行去重
5. 实现 Set 接口的常用类有 TreeSet 和 HashSet ，还有一个 LinkedHashSet ， LinkedHashSet 是在 HashSet 的基础 上维护了一个双向链表来记录元素的插入次序。
6. Set 中的 Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入
7. TreeSet 中不能插入 null 的 key ， HashSet 可以。
8. TreeSet 和 HashSet 的区别
| set底层结构 | TreeSet | HashSet |
|---|---|---|
| 底层结构 | 红黑树 | 哈希桶 |
| 插入 / 删除 / 查找时间 复杂度 | O(logN） | O(1） |
| 是否有序 | 关于 Key 有序 | 不一定有序 |
| 线程安全 | 不安全 | 不安全 |
| 插入 / 删除 / 查找区别 | 按照红黑树的特性来进行插入和删除 | 1. 先计算 key 哈希地址 2. 然后进行插入和删除 |
| 比较与覆写 | key必须能够比较，否则会抛出ClassCastException异常 | 自定义类型需要覆写 equals 和hashCode方法 |
| 应用场景 | 需要 Key 有序场景下 | Key 是否有序不关心，需要更高的时间性能 |
2.2 map常见方法
|---------------------------------------------|----------------------------------|
| V get (Object key) | 返回 key 对应的 value |
| V getOrDefault (Object key, V defaultValue) | 返回 key 对应的 value ， key 不存在，返回默认值 |
| V put (K key, V value) | 设置 key 对应的 value |
| V remove (Object key) | 删除 key 对应的映射关系 |
| Set<K> keySet () | 返回所有 key 的不重复集合 |
| Collection<V> values () | 返回所有 value 的可重复集合 |
| Set<Map.Entry<K, V>> entrySet () | 返回所有的 key-value 映射关系 |
| boolean containsKey (Object key) | 判断是否包含 key |
| boolean containsValue (Object value) | 判断是否包含 value |
注意：
- Map 是一个接口，不能直接实例化对象 ，如果 要实例化对象只能实例化其实现类 TreeMap 或者 HashMap
- Map 中存放键值对的 Key 是唯一的， value 是可以重复的
- 在 TreeMap 中插入键值对时， key 不能为空，否则就会抛 NullPointerException 异常 ， value 可以为空 。但 是HashMap 的key和value都可以为空。
- Map 中的 Key 可以全部分离出来，存储到 Set 中 来进行访问 ( 因为 Key 不能重复 ) 。
- Map 中的 value 可以全部分离出来，存储在 Collection 的任何一个子集合中 (value 可能有重复 ) 。
- Map 中键值对的 Key 不能直接修改， value 可以修改，如果要修改 key ，只能先将该 key 删除掉，然后再来进行 重新插入。
- TreeMap 和 HashMap 的区别
| Map 底层结构 | TreeMap | HashMap |
|---|---|---|
| 底层结构 | 红黑树 | 哈希桶 |
| 插入 / 删除 / 查找时间 复杂度 | O(logN) | O(1) |
| 是否有序 | 关于 Key 有序 | 无序 |
| 线程安全 | 不安全 | 不安全 |
| 插入 / 删除 / 查找区别 | 需要进行元素比较 | 通过哈希函数计算哈希地址 |
| 比较与覆写 | key 必须能够比较，否则会抛出 ClassCastException异常 | 自定义类型需要覆写 equals 和 hashCode方法 |
| 应用场景 | 需要 Key 有序场景下 | Key 是否有序不关心，需要更高的时间性能 |
2.3 Map.Entry<K, V>方法
**Map.Entry<K, V>是Map内部实现的用来存放<key, value>**键值对映射关系的内部类，该内部类中主要提供了 <key, value>的获取，value的设置以及Key的比较方式。
|---------------------|--------------------------|
| K getKey () | 返回 entry 中的 key |
| V getValue () | 返回 entry 中的 value |
| V setValue(V value) | 将键值对中的 value 替换为指定 value |
2.4 部分代码演示
java
//Set<Map.Entry<k,v>> entrySet()
Set<Map.Entry<String,Integer>> entrySet=treeMap.entrySet();
for(Map.Entry<String,Integer> entry : entrySet){
System.out.println("key:"+entry.getKey() + "val:" +entry.getValue());
}
//set
Iterator<String> it=set.iterator();
while(it.hasNext()){
System.out.print(it.next()+" ");
}三，哈希表
3.1 认识哈希
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键 码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O(logN)，搜索的效率取决于搜索过程中元素的****比较次数。
哈希方法是 ：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函 数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
向该结构中：
插入元素：根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素：对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功
3.2 哈希冲突
不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。注：冲突的发生是必然的，我们只能降低冲突。
避免冲突：1.设计合理的哈希函数
2.调节负载因子默认为0.75（负载因子=填入表中元素个数 / 散列表长度）
当++冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。++
++已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。++
3.3 解决冲突
解决哈希冲突两种常见的方法是：闭散列和开散列
3.3.1 闭散列
也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以 把key存放到冲突位置中的"下一个" 空位置中去。
1.线性探测：
从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
2.二次探测：
线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： H= (H1+ i²)% m, 或者：H= (H1- i²)% m
3.3.2 开散列
开散列法又叫链地址法 ( 开链法 )，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子 集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。
开散列，可以认为是把一个在大集合中的搜索问题转化为在小集合中做搜索了
四，部分题目
1，复制带随机指针的链表 https://leetcode.cn/problems/copy-list-with-random-pointer
我们可以申请一个map，key值用于存放更改后每个结点地址，value存放所对应的原地址。通过对每个结点调用map得到所对应的地址
java
class Solution {
public Node copyRandomList(Node head) {
HashMap<Node,Node> map=new HashMap<>();
Node cur=head;
while(cur!=null){
Node node=new Node(cur.val);
//map中key存放当前结点，node放当前节点所对应的下一个结点
map.put(cur,node);
cur=cur.next;
}
cur=head;
while(cur!=null){
map.get(cur).next=map.get(cur.next);
map.get(cur).random=map.get(cur.random);
cur=cur.next;
}
return map.get(head);
}
}2，宝石与石头 https://leetcode.cn/problems/jewels-and-stones
申请一个set集合，把宝石都放入集合，再拿取石头的元素和集合已有元素判断，有则count++
java
class Solution {
public int numJewelsInStones(String jewels, String stones) {
HashSet<Character> set=new HashSet<>();
for(int i=0;i<jewels.length();i++){
char ch=jewels.charAt(i);
set.add(ch);
}
int count=0;
for(int i=0;i<stones.length();i++){
char ch=stones.charAt(i);
if(set.contains(ch)){
count++;
}
}
return count;
}
}3.坏键盘打字 旧键盘 (20)__牛客网
题目要求最后输出大写，所有一开始我们放入集合的内容就改为大写。申请一个set集合，把实际被输入的字符先放入集合，再判断想要输入的元素是否在set集合中存在，不存在的放入set1集合中，最后输出set1集合元素
java
import java.util.Scanner;
import java.util.HashSet;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
while (in.hasNextLine()) { // 注意 while 处理多个 case
String a = in.nextLine();
String b = in.nextLine();
func(a,b);
}
}
public static void func(String a,String b){
a=a.toUpperCase();
b=b.toUpperCase();
HashSet<Character> set=new HashSet<>();
for(int i=0;i<b.length();i++){
char ch=b.charAt(i);
set.add(ch);
}
HashSet<Character> set1=new HashSet<>();
for(int i=0;i<a.length();i++){
char ch=a.charAt(i);
if(!set.contains(ch) && !set1.contains(ch)){
set1.add(ch);
System.out.print(ch);
}
}
}4.前k个高频单词（！！）：https://leetcode.cn/problems/top-k-frequent-words
1，先用hashmap统计单词频次，key-单词，value-出现次数
2.小顶堆选前k高频，频次相同在字典序大的在堆顶（方便淘汰）
3.弹出元素是从低频到高频，反转输出结果
java
class Solution {
public List<String> topKFrequent(String[] words, int k) {
HashMap<String,Integer> map=new HashMap<>();
//1.遍历words，确定每个单词出现个数
for(String word : words) {
if(map.get(word) == null) {
map.put(word,1);
}else {
int val = map.get(word);
map.put(word,val+1);
}
}
//***建立小根堆，但需特别注意当value一样时
PriorityQueue<Map.Entry<String,Integer>> min=new PriorityQueue<>(new Comparator<Map.Entry<String, Integer>>() {
public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
if(o1.getValue().compareTo(o2.getValue()) == 0) {
//按key的降序排序
return o2.getKey().compareTo(o1.getKey());
}
return o1.getValue().compareTo(o2.getValue());
}
});
//遍历map
for(Map.Entry<String,Integer> entry:map.entrySet()){
if(min.size() < k){
min.offer(entry);
}else{
Map.Entry<String,Integer> top=min.peek();
if(top.getValue().compareTo(entry.getValue())<0){
min.poll();
min.offer(entry);
}else if(top.getValue().compareTo(entry.getValue()) == 0){
if(top.getKey().compareTo(entry.getKey()) > 0) {
min.poll();
min.offer(entry);
}
}
}
}
ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < k; i++) {
Map.Entry<String,Integer> tmp = min.poll();
list.add(tmp.getKey());
}
//倒置里面的元素
Collections.reverse(list);
return list;
}
}五，总结
知识比较细碎，单看感觉难度不大，但是真的融合用起来还是有一定难度。数据结构还是太有实力了，这篇文章拖了好多天了，今天总算是写完了，天气太冷了压根不想动，但是还有好多东西没有学，任重道远，加油吧，老铁们！！方便的话麻烦点个赞哦，谢谢大家