HashMap与HashSet

一、HashMap与HashSet

1.哈希表

1.1概念

1.2常见的哈希函数：

1.3哈希-冲突

1.4冲突-减少（避免）

1.5冲突概率降低-设计哈希函数

1.6哈希冲突-负载因子（​编辑）

1.7解决冲突的办法

2、HashBuck1

3、HashBuck2

一、HashMap与HashSet

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

在现实中大多偏向于搜索的速度，哈希表就能解决当前提出的问题，如何能更快
 

1.哈希表

1.1概念

最好搜索办法就是需要谁，立刻找到，就像对应的号码背后有一个人一样，点几号就那个人，建立一个对应关系，这是最理想的搜索方法

插入元素：

把元素放到对应的编码处存储，编码的产生来源于函数（哈希函数），可以有一个特殊对应的编码，存储当前元素

搜索元素：

与插入元素有相同的地方就是还是需要哈稀函数，利用哈希函数找到对应的编码，就找到了对应的元素

在涉及哈希函数有这么及个要点：

1. 哈希函数应该尽可能简单

2. 哈希函数的值域必须在哈希表格的范围之内

3. 哈希函数的值域应该尽可能均匀分布，即取每个位置应该是等概率的

1.2常见的哈希函数：

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

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

这里我们可以先当做下标来说，当然肯定不是下标的，是一个哈希值来表示

java中哈希方法就是散列法是以哈希桶存储的

举例理解：我们先那当前的一种来做解释（除留余数法）

 上面的插入方法会很快，也仅仅只需要一个哈希函数插入和提取，但是简短的数据不能看到更其弊端，如果是11呢，余数仍然是1，那又该如何避免此现象，就会出现“冲突”。

1.3哈希-冲突

哈希冲突就如以下两个数据在调用哈希函数时，就会在下标为1的地方产生哈希冲突

里冲突就是当前哈希函数使用中出现了不同数据有了相同的哈希地址，“哈希冲突”又称“哈希碰撞”。

1.4冲突-减少（避免）

底层的数组长度往往会小于关键字数据长度，那这最终肯定会引起哈希-冲突，所以冲突发生是必然的，我只能想办法来减少冲突的发生，降低冲突概率

1.5冲突概率降低-设计哈希函数

前面已经提及了两种方法设计的哈希函数，都属于是比较常用的方法，

以下都是可以作为了解的方向去看，我们一般不会去设计一个哈希函数。

（3）. 平方取中法--(了解)
假设关键字为1234，对它平方就是1522756，抽取中间的3位227作为哈希地址； 再比如关键字为4321，对它平方就是18671041，抽取中间的3位671(或710)作为哈希地址 平方取中法比较适合：不知道关键字的分布，而位数又不是很大的情况
（4）. 折叠法--(了解)
折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些)，然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。折叠法适合事先不需要知道关键字的分布，适合关键字位数比较多的情况
（5）. 随机数法--(了解)
选择一个随机函数，取关键字的随机函数值为它的哈希地址，即H(key) = random(key),其中random为随机数函数。通常应用于关键字长度不等时采用此法
（6）. 数学分析法--(了解)
设有n个d位数，每一位可能有r种不同的符号，这r种不同的符号在各位上出现的频率不一定相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散列地址。例如：
假设要存储某家公司员工登记表，如果用手机号作为关键字，那么极有可能前7位都是 相同的，那么我们可以选择后面的四位作为散列地址，如果这样的抽取工作还容易出现 冲突，还可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移位、前两数与后两数叠加(如1234改成12+34=46)等方法。
数字分析法通常适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布较均匀的情况

注：哈希函数设计的越适应数据，冲突概率越低，但是永远不可能避免

1.6哈希冲突-负载因子（）

这里负载因子可以不能随便改值哈，有数学好的友友们，记得这的元素数据是不能改变的，我们只能改变数组的长度，来改变的负载因子的大小

1.7解决冲突的办法

散列法就可以有效解决冲突问题

散列法分为开散列和闭散列两种

 闭散列：

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

 开散列：

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

当前我们给一组数据：19，14，23，1，68，20，84，27，55，11，10，79
 

 当前数据是以一个大集合分解成多个小集合进行搜索，其实这里哈希桶搜索方法与前面闭散列方法搜索有异曲同工之妙，就我个人理解，其实都是在冲突后处置到后的数据，只是这里换成了链表

2、HashBuck1

public class HashBuck {

    public 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 useSize;

    public static final float LOAD_FACTOR=0.75f;


    public void put(int key,int val){
        //1.通过哈希函数找到位置
        int index=key% array.length;

        //2.当前数组下标的链表有没有key相同的，如果有更新val
        Node cur=array[index];
        while (cur!=null){
            if (cur.key==key){
                cur.val=val;
                return;
            }
            cur=cur.next;
        }
        //3.如果没有  进行头插法
        Node node=new Node(key,val);
        node.next=array[index];
        array[index]=node;

        useSize++;

        //4.计算当前负载因子，如果超过0.75进行扩容
        if (doLoadFactor()>=LOAD_FACTOR){
            //扩容
            resize();
        }
    }

    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){
                int neIndex=cur.key% newArray.length;
                Node curN=cur.next;
                cur.next=newArray[neIndex];
                newArray[neIndex]=cur;
                cur=curN;
            }
        }
        array=newArray;
    }

    private float doLoadFactor(){
        return useSize*1.0f/array.length;
    }

    public int get(int key){
        //1.通过哈希函数找到位置
        int index=key% array.length;

        //2.当前数组下标的链表有没有key相同的，如果有更新val
        Node cur=array[index];
        while (cur!=null){
            if (cur.key==key){
                return cur.val;
            }
            cur=cur.next;
        }
        return -1;
    }
}

3、HashBuck2

泛型：

/*public class HashBuck2<K,V> {
    public static class Node {
        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=new Node[10];


        public void put(K key,V val){
            //1.通过哈希函数找到位置
            int hashcode=key.hashCode();
            int index=hashcode%array.length;
            //2.当前数组下标的链表有没有key相同的，如果有更新val
            Node<K,V> cur=array[index];
            while (cur!=null){
                if (cur.key.equals(key)){
                    cur.val=val;
                    return;
                }
                cur=cur.next;
            }
        }

        public V get(K key){
            int hashcode=key.hashCode();
            int index=hashcode%array.length;
            Node<K,V> cur=array[index];
            while (cur!=null){
                if (cur.key==key){
                    return cur.val;
                }
                cur=cur.next;
            }
            return null;
        }
}