文章目录

前言
一、Set与Map
- 概念及场景
- 模型
- - 纯Key模型
  - Key-Value模型
- Map 的使用
- Set 的使用
二、二叉搜索树
- 什么是二叉搜索树
- 代码实现二叉搜索树
- - 查找操作
  - 插入操作
  - 删除操作(难点)
  - - cur这个节点没有左子树(cur.left == null)
    - cur这个节点没有右子树(cur.right == null)
    - cur这个节点没有左右子树(cur.left == null && cur.right == null)
    - cur这个节点有左右子树(难点)
    - 删除操作代码
- 二叉搜索树(纯Key模型版)完整代码
- 二叉搜索树性能分析
- 二叉搜索树和 java 类集的关系
三、哈希表
- 什么是哈希表
- 哈希冲突
- - 哈希冲突是什么
  - 降低哈希冲突发生的概率
  - 解决哈希冲突
- 哈希表(Key-value模型版)完整代码
- 哈希表性能分析
- 哈希表和 java 类集的关系
总结

前言

本人是一个普通程序猿!分享一点自己的见解,如果有错误的地方欢迎各位大佬莅临指导,如果你也对编程感兴趣的话，互关一下，以后互相学习，共同进步。这篇文章能够帮助到你的话,劳请大家点赞转发支持一下!

本文介绍了Map与Set的使用，也分析了其底层的实现结构，二叉搜索树与哈希桶，内容篇幅较多，但没有废话。开车喽！！！

一、Set与Map

概念及场景

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

以前常见的搜索方式有：

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

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

可能在查找时进行一些插入和删除的操作，即动态查找，那上述两种方式就不太适合了，本节介绍的Map和Set是一种适合动态查找的集合容器。

模型

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

纯Key模型

有一个英文词典，快速查找一个单词是否在词典中。
快速查找你的好友列表里是否有某个人

Key-Value模型

统计2023年高考中有多少人数学考了满分
通讯录中的手机号与备注

Map 的使用

在这里插入图片描述

Map是一个接口类，该类没有继承自Collection，该类中存储的是<K,V>结构的键值对(Key - Value模型)，并且K一定是唯一的，不能重复。

Map.Entry<K, V>的说明
Map.Entry<K, V> 是Map内部实现的用来存放<key, value>键值对映射关系的内部类，该内部类中主要提供了<key, value>的获取，value的设置以及Key的比较方式。

Map.Entry<K, V>的提供的方法

注意：Map.Entry<K,V>并没有提供设置Key的方法

方法	说明
K getKey()	返回 entry 中的 key
V getValue()	返回 entry 中的 value
V setValue(V value)	将键值对中的value替换为指定value

Map 的常用方法说明

方法	说明
V get(Object key)	返回 key 对应的 value
V getOrDefault(Object key, V defaultValue)	返回 key 对应的 value，key 不存在，返回 defaultValue
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

代码演示

    public static void main(String[] args) {
    		// 如果是new TreeMap，key不能为null会抛出空指针异常
        Map<String,Integer> map = new HashMap<>();
        map.put("电击小子",55);
        map.put("帝皇侠",66);
        map.put("哆啦A梦",77);
        map.put("迪迦奥特曼",88);
        map.put("假面骑士",99);
        int value = map.get("帝皇侠");
        int value1 = map.getOrDefault("开心超人",000);
        System.out.println("帝皇侠存在返回value：" + value);
        System.out.println("开心超人不存在返回你输入的值：：" + value1);
        // 删除了帝皇侠对应的value
        map.remove("帝皇侠");
        // 此处get返回null
        System.out.println(map.get("帝皇侠"));

        Set<String> keySet = map.keySet();
        System.out.println("map中所有的key不可重复集合：" + keySet);

        Collection<Integer> collection = map.values();
        System.out.println("map中所有的value可重复集合：" + collection);

        System.out.println("map中所有的key-value映射关系：" + map);
        Set<Map.Entry<String,Integer>> set1 = map.entrySet();
        System.out.println("map中所有的key-value映射关系：" + set1);

        System.out.println("map中是否包含key值为 帝皇侠：" + map.containsKey("帝皇侠"));
        System.out.println("map中是否包含value值为 99：" + map.containsValue(99));
    }

运行结果:
在这里插入图片描述

注意：

1️⃣Map是一个接口，不能直接实例化对象，如果要实例化对象只能实例化其实现类TreeMap或者HashMap

2️⃣Map中存放键值对的Key是唯一的，value是可以重复的

3️⃣在TreeMap中插入键值对时，key不能为空，否则就会抛NullPointerException异常，value可以为空。但是HashMap的key和value都可以为空。

4️⃣Map中的Key可以全部分离出来，存储到Set中来进行访问(因为Key不能重复)。

5️⃣Map中的value可以全部分离出来，存储在Collection的任何一个子集合中(value可能有重复)。

6️⃣Map中键值对的Key不能直接修改，value可以修改，如果要修改key，只能先将该key删除掉，然后再来进行重新插入。

7️⃣TreeMap和HashMap的区别

TreeMap和HashMap的区别

Map底层结构	TreeMap	HashMap
底层结构	红黑树	哈希桶
插入/删除/查找时间复杂度	P(log₂N)	O(1)
是否有序	关于Key有序	无序
线程安全	不安全	不安全
插入/删除/查找区别	需要进行元素比较	通过哈希函数计算哈希地址
比较与覆写	key必须能够比较，否则会抛出ClassCastException异常	自定义类型需要覆写equals和hashCode方法
应用场景	需要Key有序场景下	Key是否有序不关心，需要更高的时间性能

Set 的使用

在这里插入图片描述

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

Set 的常用方法说明

方法	说明
boolean add(E e)	添加元素，但重复元素不会被添加成功
void clear()	清空集合
boolean contains(Object o)	判断 o 是否在集合中
Iterator 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<? extendsE> c)	将集合c中的元素添加到set中，可以达到去重的效果

代码演示

    public static void main(String[] args) {
        // 如果new TreeSet，key不能为空否则会抛出空指针异常
        Set<String> set = new HashSet<>();
        // add(key):
        // 如果key不存在，则插入，返回ture
        // 如果key存在，返回false
        // 如果key是空，抛出空指针异常
        boolean flg1 = set.add("西瓜");
        System.out.println(flg1);
        boolean flg2 = set.add("西瓜");
        System.out.println(flg2);

        set.add("橘子");
        set.add("苹果");
        set.add("橙子");
        set.add("葡萄");
        set.add("榴莲");

        System.out.println(set.size());
        System.out.println(set);

        set.remove("西瓜");
        System.out.println(set);
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }

    }

运行结果：

在这里插入图片描述

注意：

1️⃣Set是继承自Collection的一个接口类

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的区别

TreeSet和HashSet的区别

Set底层结构	TreeSet	HashSet
底层结构	红黑树	哈希桶
插入/删除/查找时间复杂度	P(log₂N)	O(1)
是否有序	关于Key有序	无序
线程安全	不安全	不安全
插入/删除/查找区别	按照红黑树的特性来进行插入和删除	1. 先计算key哈希地址 2. 然后进行插入和删除
比较与覆写	key必须能够比较，否则会抛出ClassCastException异常	自定义类型需要覆写equals和hashCode方法
应用场景	需要Key有序场景下	Key是否有序不关心，需要更高的时间性能

Set与Map都是接口，他们的真正实现类是
TreeSet,HashSet;TreeMap,HashMap。
Set与Map相对于其他数据结构链表，顺序表等来说，更适用于搜索，这与他们底层的实现有关。

TreeSet与TreeMap的底层是搜索树(红黑树)

HashSet与HashMap的底层是哈希表 。

下面就让我们来用代码模拟实现一个简单的搜索树：二叉搜索树与一个哈希表你就能明白为什么Set与Map更适合搜索了

二、二叉搜索树

什么是二叉搜索树

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

1️⃣ 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值

2️⃣若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

3️⃣它的左右子树也分别为二叉搜索树

4️⃣二叉搜索树中不存在相同的值。

5️⃣二叉搜索树的中序遍历一定是一个递增序列

代码实现二叉搜索树

二叉搜索树也是一颗二叉树，只不过其对节点的值有一定性质，所以基本结构与二叉树相同

public class BinarySearchTree {
    static class TreeNode {
        // 节点的值
        int val;
        // 左子树
        TreeNode left;
        // 右子树
        TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }
    
    // 根节点
    public TreeNode root = null;
}

查找操作

查找操作，主要利用搜索二叉树的性质，
左子树的值都小于根节点，右子树的值都大于根节点，
让值与每颗二叉搜索树的根节点去比较，然后再判断该去左右哪个子树寻找。

    // 查找操作
    public TreeNode find(int val) {
        // 从根节点开始找
        TreeNode cur = root;
        while (cur != null) {
            // 找到返回节点
            if(cur.val == val) {
                return cur;
            }
            
            if(cur.val > val) {
                // 如果节点值大于要查找的数，
                // 证明要查找的数在左子树
                cur = cur.left;
            } else {
                // 如果节点值小于要查找的数，
                // 证明要查找的数在右子树
                cur = cur.right;
            }
        }
        // 出了循环，即没找到
        return null;
    }

插入操作

插入操作，也是利用搜索二叉树的性质，
左子树的值都小于根节点，右子树的值都大于根节点，
让要插入的值与每颗二叉搜索树的根节点去比较，然后再判断该插入左右哪个子树。

    //插入操作
    public void insert(int val) {
        
        if(root == null) {
            // 如果是空树，那么直接插入到根节点的位置
            root = new TreeNode(val);
            return;
        }
        // 当前节点
        TreeNode cur = root;
        // 父亲节点
        TreeNode pre = null;
        while (cur != null) {
            if(cur.val == val) {
                // 二叉搜索树不存在相同的值，
                // 找到相同值，直接放弃插入
                return;
            }
            // 父亲节点往下走
            pre = cur;
            if(val > cur.val) {
                // 要插入的值，大于当前节点的值
                // 去右子树寻找合适位置
                cur = cur.right;
            } else {
                // 要插入的值，小于当前节点的值
                // 去左子树寻找合适位置
                cur = cur.left;
            }
        }
        
        // 出了循环，证明此时的cur就是要插入的位置
        // 判断大小，证明此时的cur是左子树还是右子树，
        // 然后进行插入
        if(pre.val < val) {
            pre.right = new TreeNode(val);
        } else {
            pre.left = new TreeNode(val);
        }
    }

删除操作(难点)

删除操作，也是利用搜索二叉树的性质，
左子树的值都小于根节点，右子树的值都大于根节点，
让要插入的值与每颗二叉搜索树的根节点去比较，然后再判断该去左右哪个子树寻找要删除的节点。
找到了要怎么删，才是难点！！！

切记切记切记，下面的各种情况下的删除操作，都是以这个为前提，至于如何找到cur与parent相信大家已经都会了

设待删除结点为 cur, 待删除结点的双亲结点为 parent 。

cur这个节点没有左子树(cur.left == null)

这也分为三种情况

1️⃣cur是二叉搜索树的根节点root，如下图

此时的删除呢，就比较简单。直接让根节点等于他的右子树
即： root == root.right;

2️⃣cur != root，cur == parent.left ,如下图

此时的删除呢，也比较简单。直接让父亲节点的左子树等于删除节点的右子树
即： parent.left = cur.right;

3️⃣cur != root，cur == parent.right ,如下图

此时的删除呢，也比较简单。直接让父亲节点的左子树等于删除节点的右子树
即： parent.left = cur.right;

cur这个节点没有右子树(cur.right == null)

与上述的三种情况相同，相信大伙已经知道这个条件下，删除操作如何写了。

cur这个节点没有左右子树(cur.left == null && cur.right == null)

此时随意代入没有左子树情况或没有右子树情况即可。

cur这个节点有左右子树(难点)

在这里插入图片描述

此时的删除操作使用的是替换法。有两种操作实现替换法：
1️⃣让 cur的左子树中最大的数来替换掉待删除节点

2️⃣让 cur的右子树中最小的数来替换掉待删除节点

此时就完成了对cur的删除，且这棵树仍符合二叉搜索树的性质。

删除操作代码

    // 删除操作
    public void remove(int key) {
        TreeNode cur = root;
        TreeNode parent = null;
        // 找到待删除节点cur
        // 与待删除节点的父亲节点parent
        while (cur != null) {
            if(cur.val == key) {
                break;
            }
            parent = cur;
            if(cur.val > key) {
                cur = cur.left;
            } else {
                cur = cur.right;
            }
        }
        // 交给删除方法
        removeNode(parent,cur);
    }
    private void removeNode(TreeNode parent,TreeNode cur) {
        if(cur.left == null) {
            // cur没有左子树情况
            if(cur == root) {
                // cur是根节点
                root = cur.right;
                return;
            } else if(cur == parent.left) {
                // cur不是根节点，是父亲节点的左子树
                parent.left = cur.right;
                return;
            } else  {
                // cur不是根节点，是父亲节点的右子树
                parent.right = cur.right;
                return;
            }
        } else if(cur.right == null) {
            // cur没有右子树情况
            if(cur == root) {
                // cur是根节点
                root = cur.left;
                return;
            } else if(cur == parent.left) {
                // cur不是根节点，是父亲节点的左子树
                parent.left = cur.left;
                return;
            } else  {
                // cur不是根节点，是父亲节点的右子树
                parent.right = cur.left;
                return;
            }
        }else {
            // cur有左右子树情况
            // 此处使用的替换法是用cur左子树中最大值来替换掉cur
            TreeNode target = cur.left;
            // target为左子树的根节点
            TreeNode targetParent = cur;
            // targetParent为target的父亲节点
            while (target.right != null) {
                // 找到左子树中最大值
                targetParent = target;
                target = target.right;
            }
            // 完成替换
            cur.val = target.val;
            // 删除替换cur的节点，target节点
            if(target == targetParent.right) {
                // 如果if判断成功，那么证明target一定没有右子树了，
                // 此时的targetParent != cur，target == targetParent.right
                // 删除target节点就转换成了删除不是根节点且没有右子树的节点的问题
                targetParent.right = target.left;
            }else {
                // 如果if判断失败，就证明一次while语句都没走，
                // 也就是说cur的左子树根节点，这个根节点，没有右子树
                // 因此cur的左子树中最大值即为这棵树的根节点
                // 此时的targetParent == cur，target == cur.left
                // 删除target节点就转换成了删除不是根节点且没有右子树的节点的问题
                targetParent.left = target.left;
            }
        }
    }

二叉搜索树(纯Key模型版)完整代码

public class BinarySearchTree {
    static class TreeNode {
        // 节点的值
        int val;
        // 左子树
        TreeNode left;
        // 右子树
        TreeNode right;

        public TreeNode(int val) {
            this.val = val;
        }
    }

    // 根节点
    public TreeNode root = null;

    // 查找操作
    public TreeNode find(int val) {
        // 从根节点开始找
        TreeNode cur = root;
        while (cur != null) {
            // 找到返回节点
            if(cur.val == val) {
                return cur;
            }

            if(cur.val > val) {
                // 如果节点值大于要查找的数，
                // 证明要查找的数在左子树
                cur = cur.left;
            } else {
                // 如果节点值小于要查找的数，
                // 证明要查找的数在右子树
                cur = cur.right;
            }
        }
        // 出了循环，即没找到
        return null;
    }


    //插入操作
    public void insert(int val) {

        if(root == null) {
            // 如果是空树，那么直接插入到根节点的位置
            root = new TreeNode(val);
            return;
        }
        // 当前节点
        TreeNode cur = root;
        // 父亲节点
        TreeNode pre = null;
        while (cur != null) {
            if(cur.val == val) {
                // 二叉搜索树不存在相同的值，
                // 找到相同值，直接放弃插入
                return;
            }
            // 父亲节点往下走
            pre = cur;
            if(val > cur.val) {
                // 要插入的值，大于当前节点的值
                // 去右子树寻找合适位置
                cur = cur.right;
            } else {
                // 要插入的值，小于当前节点的值
                // 去左子树寻找合适位置
                cur = cur.left;
            }
        }

        // 出了循环，证明此时的cur就是要插入的位置
        // 判断大小，证明此时的cur是左子树还是右子树，
        // 然后进行插入
        if(pre.val < val) {
            pre.right = new TreeNode(val);
        } else {
            pre.left = new TreeNode(val);
        }
    }

    // 删除操作
    public void remove(int key) {
        TreeNode cur = root;
        TreeNode parent = null;
        // 找到待删除节点cur
        // 与待删除节点的父亲节点parent
        while (cur != null) {
            if(cur.val == key) {
                break;
            }
            parent = cur;
            if(cur.val > key) {
                cur = cur.left;
            } else {
                cur = cur.right;
            }
        }
        // 交给删除方法
        removeNode(parent,cur);
    }
    private void removeNode(TreeNode parent,TreeNode cur) {
        if(cur.left == null) {
            // cur没有左子树情况
            if(cur == root) {
                // cur是根节点
                root = cur.right;
                return;
            } else if(cur == parent.left) {
                // cur不是根节点，是父亲节点的左子树
                parent.left = cur.right;
                return;
            } else  {
                // cur不是根节点，是父亲节点的右子树
                parent.right = cur.right;
                return;
            }
        } else if(cur.right == null) {
            // cur没有右子树情况
            if(cur == root) {
                // cur是根节点
                root = cur.left;
                return;
            } else if(cur == parent.left) {
                // cur不是根节点，是父亲节点的左子树
                parent.left = cur.left;
                return;
            } else  {
                // cur不是根节点，是父亲节点的右子树
                parent.right = cur.left;
                return;
            }
        }else {
            // cur有左右子树情况
            // 此处使用的替换法是用cur左子树中最大值来替换掉cur
            TreeNode target = cur.left;
            // target为左子树的根节点
            TreeNode targetParent = cur;
            // targetParent为target的父亲节点
            while (target.right != null) {
                // 找到左子树中最大值
                targetParent = target;
                target = target.right;
            }
            // 完成替换
            cur.val = target.val;
            // 删除替换cur的节点，target节点
            if(target == targetParent.right) {
                // 如果if判断成功，那么证明target一定没有右子树了，
                // 此时的targetParent != cur，target == targetParent.right
                // 删除target节点就转换成了删除不是根节点且没有右子树的节点的问题
                targetParent.right = target.left;
            }else {
                // 如果if判断失败，就证明一次while语句都没走，
                // 也就是说cur的左子树根节点，这个根节点，没有右子树
                // 因此cur的左子树中最大值即为这棵树的根节点
                // 此时的targetParent == cur，target == cur.left
                // 删除target节点就转换成了删除不是根节点且没有右子树的节点的问题
                targetParent.left = target.left;
            }
        }
    }
    // 中序遍历
    public void display(TreeNode cur) {
        if(cur == null) {
            return;
        }
        display(cur.left);
        System.out.print(cur.val + " ");
        display(cur.right);
    }
}

二叉搜索树性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

插入：3，4，5，6，7，8，9这些数

查找效率：
最优情况下，二叉搜索树为完全二叉树，其查找一个数平均比较次数为:
log₂N
最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N/2

二叉搜索树和 java 类集的关系

TreeMap 和 TreeSet 即 java 中利用搜索树实现的 Map 和
Set；实际上用的是红黑树，而红黑树是一棵近似平衡的二叉搜索树，即在二叉搜索树的基础之上 +颜色以及红黑树性质验证，关于红黑树的内容后序再进行讲解。

三、哈希表

什么是哈希表

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O（log₂N），搜索的效率取决于搜索过程中元素的比较次数。理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。

如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：
插入元素
根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
搜索元素
对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

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

图解
为简单明了，存储的数据的类型均为int，关键码均为要存入的数字本身

假设
存储数据的数组是一个容量为10的数组。

hashFunc哈希方法为：hash(存储位置) = key(数据的值) % (取模运算符) capacity(存储数据的数组的大小)

哈希表其实就是一个数组，哈希表只是让你存入的元素与存储位置之间通过哈希函数有了一个映射关系。

用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快。

哈希冲突

哈希冲突是什么

对于两个数据元素的关键字 K_i 和 K_j (i != j)，有 K_i != K_j ，但有：Hash( ) == Hash( ) ，即：不同关键码通过相同哈希函数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞。

图解

此时20与100就发生了哈希冲突。

降低哈希冲突发生的概率

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

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

哈希函数设计原则：

1️⃣哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间。

2️⃣哈希函数计算出来的地址能均匀分布在整个空间中。

3️⃣哈希函数应该比较简单。

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

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

3️⃣平方取中法–(了解)
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址；再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址。
平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况

4️⃣折叠法–(了解)
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况

5️⃣ 随机数法–(了解)
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。
随机数法通常应用于关键字长度不等时。

6️⃣数学分析法–(了解)
设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。
数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

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

除了哈希函数的不合理可能会引起哈希冲突，还有另一个原因：负载因子过大。

负载因子定义为： α = 哈希表中已有的元素个数 / 哈希表的长度

α与哈希表中的元素个数成正比，因此α越大，哈希表中的数据越多，产生哈希冲突的可能性就越大；反之α越小，哈希表中的数据越少，产生哈希冲突的可能性就越小。

所以当冲突率达到一个无法忍受的程度时，我们需要通过降低负载因子来变相的降低冲突率。
已知哈希表中已有的关键字个数是不可变的，那我们能调整的就只有哈希表中的数组的大小。

所以我们可以给负载因子设置一个阈值，负载因子超过这个值，数组就进行扩容
。

解决哈希冲突

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

解决哈希冲突：闭散列

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

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

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

2️⃣线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为：H_i= (H₀+i²)% m, 或者：H_i= (H₀-i²)% m。其中：i = 1,2,3…，是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小。
说白了，就是再次通过一个函数来计算下一个位置，就不做演示了。

因此：比散列最大的缺陷就是空间利用率比较低，这也是哈希的缺陷。

解决哈希冲突：开散列

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

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

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

哈希表(Key-value模型版)完整代码

普通版本

public class HashBuck {
    // 哈希桶中的节点类型
    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 = new Node[10];
    // 数组中的数据个数
    public int usedSize;
    // 负载因子阈值
    public final static double LOAD_FACTOR = 0.75;

    //插入操作
    public void put(int key,int val) {
        // 哈希函数
        int index = key % array.length;
        Node cur = array[index];

        //判断链表中是否存在key，存在更新val
        while (cur != null) {
            if(cur.key == key) {
                cur.val = val;
                return;
            }
            cur = cur.next;
        }

        //不存在采用头插法插入链表
        Node node = new Node(key,val);
        node.next = array[index];
        array[index] = node;
        usedSize++;
    }

    //扩容，并将原哈希桶中的数，重新插入新的合适位置
    private void resize() {
        Node[] newArray = new Node[array.length*2];
        for (int i = 0; i < array.length; i++) {
            Node cur = array[i];
            // 因为扩容了，所以可能有一些以前哈希冲突的数据，现在不会发生哈希冲突，
            // 因此每个链表中的数据除了头节点，都要重新计算地址，重新插入
            while(cur != null) {
                Node curNext = cur.next;
                int index = cur.key % array.length*2;
                cur.next = newArray[index];
                newArray[index] = cur;
                cur = curNext;
            }
        }
        array = newArray;
    }

    //返回当前负载因子
    private double calculateLoadFactor() {
        return usedSize*1.0/array.length;
    }

    // 找到key对应的value值，没有key返回-1
    public int get(int key) {
        int index = key % array.length;
        Node cur = array[index];
        while(cur != null) {
            if(cur.key == key) {
                return cur.val;
            }
            cur = cur.next;
        }
        return -1;
    }
}

泛型版本

public class HashBuck1<K,V> {
    // 哈希桶中的节点类型
    static class Node<K,V> {
        public K key;
        public V val;
        public Node<K,V> next;
        public Node(K key, V val) {
            this.key = key;
            this.val = val;
        }
    }
    // 存放数据的数组
    public Node<K,V>[] array = (Node<K,V>[])new Node[10];
    // 数组中的数据个数
    public int usedSize;
    // 负载因子阈值
    public static final double LOAD_FACTOR = 0.75;


    public void put(K key,V val) {
        // Object类中提供了哈希函数，
        // 因此任何类型都可以使用父类Object中的哈希函数
        // hashCode方法会通过计算返回给你一个整数
        int hash = key.hashCode();
        int index = hash % array.length;
        Node<K,V> cur = array[index];

        //判断链表中是否存在key，存在更新val
        while (cur != null) {
            if(cur.key.equals(key)) {
                cur.val = val;
                return;
            }
            cur = cur.next;
        }

        //不存在采用头插法插入链表
        Node<K,V> node = new Node<>(key,val);
        node.next = array[index];
        array[index] = node;
        usedSize++;
    }

    // 扩容操作，并将原哈希表中的数，重新放入到新的哈希表中
    private void resize() {
        Node<K,V>[] newArray = (Node<K, V>[]) new Node[array.length*2];
        for (int i = 0; i < array.length; i++) {
            Node<K,V> cur = array[i];
            // 因为扩容了，所以可能有一些以前哈希冲突的数据，现在不会发生哈希冲突，
            // 因此每个链表中的数据除了头节点，都要重新计算地址，重新插入
            while(cur != null) {
                Node curNext = cur.next;
                int hash = cur.key.hashCode();
                int index = hash % array.length*2;
                cur.next = newArray[index];
                newArray[index] = cur;
                cur = curNext;
            }
        }
        array = newArray;
    }

    // 返回当前负载因子
    private double calculateLoadFactor() {
        return usedSize*1.0/array.length;
    }

    // 找到key对应的value值，没有key返回null
    public V get(K key) {
        int hash = key.hashCode();
        int index = hash % array.length*2;
        Node<K,V> cur = array[index];
        while(cur != null) {
            if(cur.key.equals(key)) {
                return cur.val;
            }
            cur = cur.next;
        }
        return null;
    }
}

哈希表性能分析

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

哈希表和 java 类集的关系

1️⃣HashMap 和 HashSet 即 java 中利用哈希表实现的 Map 和 Set

2️⃣java中使用的是哈希桶方式解决冲突的

3️⃣java 会在冲突链表长度大于一定阈值后，将链表转变为搜索树（红黑树）

4️⃣java中计算哈希值实际上是调用的类的 hashCode 方法，进行 key 的相等性比较是调用 key 的 equals方法。所以如果要用自定义类作为HashMap 的 key 或者 HashSet 的值，必须覆写 hashCode 和 equals 方法，而且要做到 equals 相等的对象，hashCode 一定是一致的。