数据结构（Java实现）-Map和Set

搜索树
概念
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

---

二叉搜索树的实现
建立基本的节点

---

在搜索树中查找 key，如果找到，返回 key 所在的结点，否则返回 null

---

操作-插入



利用插入操作建立一颗搜索树

---

删除元素
分为三种情况
前两种情况

自己画图分析，更好理解
第3种情况

上述的意思是找到右分支的最左边的元素target，将要删除的元素用target替换



测试

运行结果如下

---

TreeMap 和 TreeSet 即 java 中利用搜索树实现的 Map 和 Set；实际上用的是红黑树

---

Map和set是一种专门用来进行搜索的容器或者数据结构，其搜索的效率与其具体的实例化子类有关。
以前常见的搜索方式有：

1. 直接遍历，时间复杂度为O(N)，元素如果比较多效率会非常慢
2. 二分查找，时间复杂度为O（logN） ,但搜索前必须要求序列是有序的

上述排序比较适合静态类型的查找，即一般不会对区间进行插入和删除操作了
而现实中的查找比如：

1. 根据姓名查询考试成绩
2. 通讯录，即根据姓名查询联系方式
3. 不重复集合，即需要先搜索关键字是否已经在集合中

可能在查找时进行一些插入和删除的操作，即动态查找
Map和Set是一种适合动态查找的集合容器。

---

模型
一般把搜索的数据称为关键字（Key），和关键字对应的称为值（Value），将其称之为Key-value的键值对，所以模型会有两种：

1. 纯 key 模型，比如：
   有一个英文词典，快速查找一个单词是否在词典中
   快速查找某个名字在不在通讯录中
2. Key-Value 模型，比如：
   统计文件中每个单词出现的次数，统计结果是每个单词都有与其对应的次数：<单词，单词出现的次>
   梁山好汉的江湖绰号：每个好汉都有自己的江湖绰号

Map中存储的就是key-value的键值对，Set中只存储了Key。

---

Map 的使用
Map是一个接口类，该类没有继承自Collection，该类中存储的是结构的键值对，并且K一定是唯一的，不能重复。
Map 的常用方法说明

上述说明，相同的key的情况下，会更新value

---

---

---

---

---

---

Set 的说明
Set与Map主要的不同有两点：Set是继承自Collection的接口类，Set中只存储了Key。

---

注意：

1. Set是继承自Collection的一个接口类
2. Set中只存储了key，并且要求key一定要唯一
3. TreeSet的底层是使用Map来实现的，其使用key与Object的一个默认对象作为键值对插入到Map中的
4. Set最大的功能就是对集合中的元素进行去重
5. Set中的Key不能修改，如果要修改，先将原来的删除掉，然后再重新插入
6. TreeSet中不能插入null的key
   

---

哈希表
顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( )，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。 如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。

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

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(HashTable)(或者称散列表)

---

---

按照上述哈希方式，向集合中插入元素44，会出现什么问题？

---

不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。
由于我们哈希表底层数组的容量往往是小于实际要存储的关键字的数量的，这就导致一个问题，冲突的发生是必然的，但我们能做的应该是尽量的降低冲突率。

---

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

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

---

常见哈希函数

1. 直接定制法–(常用)
   取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B 优点：简单、均匀 缺点：需要事先知道关键字的分布情况 使用场景：适合查找比较小且连续的情况
   如下
   

---

2. 除留余数法–(常用)
   设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址

---

冲突-避免-负载因子调节

---

负载因子和冲突率的关系粗略演示

已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

---

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

---

1. 线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
   

---

二次探测


闭散列最大的缺陷就是空间利用率比较低

---

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

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

---

哈希桶的实现

放入数据 ：put

结果如下：

---

取数据 get

---

哈希表泛型的实现

在没有重写hashcode之前，我们看到，两个对象的hashcode的值是不一样的

当我们将id看作身份证件时，那么两者的hanshcode应该是相同的，因此，这里我们改写hashcode方法

---

通常意义下，我们认为哈希表的插入/删除/查找时间复杂度是O(1) 。

---

可以利用hashSet进行去重，去掉重复的数据

---

---

将新的节点和旧的节点放到一个hashmap中，用来搭建新旧节点之间的联系；

在复制的过程中，val值可以直接复制到新的节点中，next和random的值可以通过以下方式确定
map.get(cur).next=map.get(cur.next)
map.get(cur).random=map.get(cur.random)

---

---

---

---

class Test23{
    public static List<String> topKFrequent(String[] words, int k) {
        //1、每个单词出现的次数
        Map<String,Integer> map = new HashMap<>();
        for(String s : words) {
            if(map.get(s) == null) {
                map.put(s,1);
            }else {
                //以前有
                int val = map.get(s);
                map.put(s,val+1);
            }
        }

        //2、已经统计完毕，创建小根堆
        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) {
                    return o2.getKey().compareTo(o1.getKey());//根据字母顺序 变成大根堆
                }
                return o1.getValue().compareTo(o2.getValue());
            }
        });

        //3.遍历map
        for (Map.Entry<String,Integer> entry: map.entrySet()) {
            if(minHeap.size()<k){
                minHeap.offer(entry);
            }else{//小根堆已满
                Map.Entry<String,Integer> top=minHeap.peek();
                if(top.getValue().compareTo(entry.getValue())==0){//频率一样的情况下，判断key值，key小的入
                    if(top.getKey().compareTo(entry.getKey())>0){
                        //entry 进
                        minHeap.poll();
                        minHeap.offer(entry);
                    }
                }else{//val值不等，只有大于堆顶元素的频率，才有资格入堆
                    if(top.getValue().compareTo(entry.getValue())<0){
                        minHeap.poll();
                        minHeap.offer(entry);
                    }

                }
            }
        }

        //4 将小根堆中的元素拿出，放到一个集合里，之后逆置
        List<String> list=new ArrayList<>();
        for (int i = 0; i <k; i++) {
            String s=minHeap.poll().getKey();
            list.add(s);
        }
        Collections.reverse(list);
        return list;
        }

    public static void main(String[] args) {
        String[] strings={"a","b","c","c"};
        List<String> ret=topKFrequent(strings,3);
        System.out.println(ret);
    }
    }

---