哈希表

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

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

3、核心：（1）内部是一个数组；
（2）关键字经过变换(hash函数)得到int类型的值；
（3）int类型的值变成一个合法(不能越界，例：数组的长度只有10，但是你要把关键码放在97下标的位置是不合法的)的下标；
（4）把关键字放到这个合法的下标的位置。

4、降低冲突的两种方式： ①设计哈希函数时注点意；②通过扩容降低负载因子，来降低冲突。

负载因子 = 哈希表的数据个数 / 数组的长度

5、解决冲突的两种方式： 闭散列和开散列

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

7、和java类集的关系：

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

put函数实现的步骤：
put(int key,int value){
	1、通过设计的哈希函数，找到对应的位置，头插或尾插进数组；
	2、判断是否需要扩容，若需要进行扩容，就将原来的空间扩大2倍；
	3、空间扩容后，需要将数组对应下标处有节点的节点全部都遍历一遍和哈希一遍，重新判断位置在哪，然后再头插或尾插进去。
}

import java.util.HashMap;

//实现的是哈希桶：数组+链表+红黑树
class HashBuck{
    static class Node{//构造一个内部类，这个类里定义的是要往数组里插入的结点的属性及其构造方法
        public int key;
        public int value;
        public Node next;
        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }
    public Node[] array=new Node[10];//定义一个数组
    public int usedSize;//记录插入的结点个数

    //1、往哈希表里存放数据（每插入一个数据就调用一次函数）
    public void put(int key,int value){
    //这里应该是一开始就定义了一个节点cur放在array[index]的位置，当cur不空时，将要插入的值填充进cur
        int index=key % array.length;
        for(Node cur=array[index];cur!=null;cur=cur.next){
            if(cur.key==key){//如果要插入的结点key相等，value不等，就把value的值更新为最新的值
                cur.value=value;
                return;
            }
        }
        //头插
        Node node=new Node(key,value);//当数组下标对应数据为空时，第一次插入数据就不用经过上面那个循环，直接到这一步
        node.next=array[index];//到这一步进行头插，初始array[index]=null,第一次到这里的时候，插完结点时，结点的next部分自然为空
        array[index]=node;
        this.usedSize++;//每插入一个就加1
        if(loadFactor()>0.75){
            resize();
        }
    }
    public double loadFactor(){//判断负载因子的状况。负载因子=数据总数 / 数组长度
        return this.usedSize*1.0 / this.array.length;
    }
    public void resize(){//扩容之后遍历原来的数组将对应下标有节点的重新哈希一遍，放到该放的位置
        Node[] newArray=new Node[2*this.array.length];
        for(int i=0;i<array.length;i++){
            Node cur=array[i];
            while(cur!=null){
                Node curNext=cur.next;//防止落下某个节点
                int index=cur.key % newArray.length;
                cur.next=newArray[index];
                newArray[index]=cur;
                cur=curNext;
            }
            array=newArray;//还原到原来的数组
        }
    }

    //2、在哈希表找key对应的value
    public int get(int key){
        int index=key%array.length;
        Node cur=array[index];
        while(cur!=null){
            if(cur.key==key){
                return cur.value;
            }
            cur=cur.next;
        }
        return -1;//表示没找到
    }
}
public class Hash {
    public static void main(String[] args) {
        HashBuck hashBuck=new HashBuck();
        for (int i = 1; i <4 ; i++) {
            hashBuck.put(i,i);
        }
        hashBuck.put(11,101);

        System.out.println(hashBuck.get(11));
    }
}

泛型版本：

//举的一小栗子
/*nimport java.util.Objects;
class Person{
    public int id;

    public Person(int id){
        this.id=id;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return id == person.id;
    }
    @Override
    public int hashCode() {

        return Objects.hash(id);
    }
    /*public static void main(String[] args) {
        Person person1=new Person(12);
        Person person2=new Person(12);

        System.out.println(person1.hashCode());//hashCode()找位置并显示出来
        System.out.println(person2.hashCode());
        //若要找到对应的确切的值，需要重写hashCode()和equals()方法
        //若不重写hashCode()方法，对应的值找不对
        //若不重写equals()方法，会错过可能已经找到的值
        System.out.println(person1.equals(person2));//判断两个对象的位置(地址)是否相同
    }
}
*/


//正式开始
import java.util.Objects;
public class HashBuck1<K,V>{//泛型。<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;
        }
		//重写的equals()和hashCode()方法
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Node<?, ?> node = (Node<?, ?>) o;
            return Objects.equals(key, node.key) &&
                    Objects.equals(value, node.value) &&
                    Objects.equals(next, node.next);
        }
        @Override
        public int hashCode() {
            return Objects.hash(key, value, next);
        }

    }
    public Node<K,V>[] array=(Node<K,V>[])new Node[10];//定义一个数组也要是<K,V>类型的
    public int usedSize;//记录插入的结点个数

    public void put(K key,V value){
        //int index=key.hashCode();//hashCode()找位置。这个方法自动生成一个合法的下标，只是这样容易越界.所以看下面
        int hash=key.hashCode();
        int index=hash % array.length;//使生成的合法下标再%一个数组的长度也可
        for(Node cur=array[index];cur!=null;cur=cur.next){
            //判断引用类型里的是否相等可不敢用==，而是要用equals，而且还是重写过的equals
            if(cur.key.equals(key)){
                cur.value=value;
                return;
            }
        }
        Node<K,V> node=new Node<>(key,value);//头插结点
        node.next=array[index];
        array[index]=node;
        this.usedSize++;
        if(loadFactor()>0.75){
            resize();
        }
    }
    public double loadFactor(){//判断负载因子的状况。负载因子=数据总数 / 数组长度
        return this.usedSize*1.0 / this.array.length;
    }
    public void resize(){//扩容之后遍历原来的数组将对应下标有节点的重新哈希一遍，放到该放的位置
        Node[] newArray=new Node[2*this.array.length];
        for(int i=0;i<array.length;i++){
            Node cur=array[i];
            while(cur!=null){
                Node curNext=cur.next;//防止落下某个节点
                int index=cur.key.hashCode() % newArray.length;
                cur.next=newArray[index];
                newArray[index]=cur;
                cur=curNext;
            }
            array=newArray;//还原到原来的数组
        }
    }

    public V get(K key){
        //1、找位置
        //2、遍历单链表开始找,找到返回value值
        int index=key.hashCode() % array.length;
        Node<K,V> cur=array[index];
        while(cur!=null){
            if(cur.key.equals(key)){
                return cur.value;
            }
            cur=cur.next;
        }
        return null;//表示没找到
    }
    public static void main(String[] args) {

    }
}
//数据是引用类型时，一定要用equals()来比较,当类是Person时，一定要重写hashCode()和equals()方法
//hashCode()找值
//equals()比较值