哈希哈希

前言：
　　哈希表（Hash Table）也叫散列表,是一种用于快速存取的数据结构。其内部实现是通过把键（key）码映射到表中的一个位置来访问记录，其中的“映射”也就是哈希函数，而“表”即哈希表。本文将重点介绍实现哈希表的2种方法：拉链法和线性探测法。

1.实验数据

A 2
C 1
B 6
B 11
H 1
J 3
数据说明：为了跟前面博文保持一致，本文的数据依然采用键值对（Key-Value）的形式。哈希表中主要有"存"和"取"操作。前者为:void put(Key key,Value);后者为: Value get(Key key);执行put操作时，如果数据已经存在则更新为新数据。

2.HashMap实现

　　实现哈希表主要分以下两步：
step1:定义哈希函数
　　哈希函数的实现不唯一，在此我们以java自带的hashCode()为基础进行修改。(对hashCode()底层实现感兴趣的朋友可另找资料进行了解~)

public int hash(Key key){
        return (key.hashCode() & 0x7fffffff)%M;
    }

step2:解决哈希冲突
　　当出现 hash（k1）== hash(k2)时，即产生冲突。
解决方法一（拉链法）：因为哈希值相等，我们可以将k1,k2利用链表 st 进行存储。即，凡是hash(x)相等的x都存入同一链表。当要进行查找操作时，先利用hash(x)定位到链表st[hash(x)]，再通过顺序链表遍历进行查找。
解决方法二（线性探测法）：利用两张足够大的哈希表 keys[M]和Values[M]（其中，M>=2*N），当出现冲突之后，顺势循环向下遍历查找还没有存放 key 的keys[hash(key)]，直到找到keys[hash(key)]==null为止。
------------

拉链法与线性探测法的存储比较：

3.Java代码实现
a.拉链法code：

package com.gdufe.hash;

import java.io.File;
import java.util.Scanner;

public class SequenceChain<Key,Value>{

    private int N;
    private int M;
    private SequentialSearch<Key, Value> []st;
    
    public SequenceChain() {
        this(997);
    }
    String s;
    public SequenceChain(int M){
        this.M = M;        //赋值M
        st = (SequentialSearch<Key,Value>[]) new SequentialSearch[M];
        for(int i=0;i<M;i++)
            st[i] = new SequentialSearch();    //初始化
    }
    
    public int hash(Key key){    //自定义哈希，防止哈希值为负
        return (key.hashCode() & 0x7fffffff) % M;   
    }
    public void put(Key key,Value value){
        st[hash(key)].put(key, value);
    }
    public Value get(Key key){
        return st[hash(key)].get(key);
    }
    
    public static void main(String[] args) throws Exception{
        Scanner input = new Scanner(new File("data_hash.txt"));
        SequenceChain<String, Integer> sequence = new SequenceChain<String, Integer>();
        while(input.hasNext()){
            String key = input.next();
            int value = input.nextInt();
            sequence.put(key, value);
        }
        input.close();    //关闭控制台输入
        System.out.println("-----output----");
        System.out.println(sequence.get("H"));
        System.out.println(sequence.get("B"));
        
    }

}

辅助数据结构---顺序链表code:

package com.gdufe.hash;

import java.io.File;
import java.util.Scanner;

public class SequentialSearch<Key,Value> {
    
    private Node root;    //顺序链表的根root
    class Node{
        Key key;
        Value value;
        Node next;
        public Node(Key key,Value value){
            this.key=key;
            this.value=value;
        }
    }
    //在表头新增结点
    public void put(Key key,Value value){
        if(get(key)!=null){            //更新即可
            for(Node x=root;x!=null;x=x.next){
                if(x.key.equals(key)){
                    x.value=value;
                    return;
                }
            }
        }
        Node h = new Node(key,value);
        h.next=root;
        root = h;
    }
    
    public Value get(Key key){
        for(Node x=root;x!=null;x=x.next){
            if(x.key.equals(key)){
                return x.value;
            }
        }
        return null;
    }
    
}    

b.线性探测法code:

package com.gdufe.hash;

import java.io.File;
import java.util.Scanner;

public class LinearIndex<Key,Value> {
    
    int N=0;
    int M=16;    //初始大小
    Key[] keys;
    Value[] values;
    
    public LinearIndex() { 
        keys = (Key[]) new Object[M];   //强制转型
        values = (Value[]) new Object[M];
    }
    public void put(Key key,Value value){
        if(N*2>=M) resize();  //扩大哈希表
        int i;
        for(i=hash(key);keys[i]!=null;i=(i+1)%M){
            if(keys[i].equals(key)){  //    更新value
                values[i]=value;
                return;        
            }
        }
        keys[i]=key;
        values[i]=value;
        N++;
    }
    
    private void resize() {        //扩大一倍
        Key[] keyTemp = (Key[]) new Object[2*keys.length];
        System.arraycopy(keys, 0, keyTemp, 0, keys.length);
        keys = keyTemp;
        Value[] valueTemp = (Value[]) new Object[2*values.length];
        System.arraycopy(values, 0, valueTemp, 0, values.length);
        values = valueTemp;
        
        M = M*2;    //shouldn't be neglected!
    }
    public Value get(Key key){
        for(int i=hash(key);keys[i]!=null;i=(i+1)%M){
            if(keys[i].equals(key))
                return values[i];
        }
        return null;
    }
    public int hash(Key key){
        return (key.hashCode() & 0x7fffffff)%M;
    }
    
    public static void main(String[] args) throws Exception {
        Scanner input = new Scanner(new File("data_BST.txt"));
        LinearIndex<String, Integer> li = new LinearIndex<String, Integer>();
        while(input.hasNext()){
            String key = input.next();
            int value = input.nextInt();
            li.put(key, value);
        }
        input.close();
        System.out.println("-----output----");
        System.out.println(li.get("H"));
        System.out.println(li.get("B"));
    }
}

4.测试结果

-----output----
1
11

注意：

　　（1）Java底层实现HashMap采用的是上述介绍的拉链法。关于HashMap的底层实现在Java面试中是面试官喜欢问的问题之一。

　　（2）关于拉链法采用的辅助结构为什么选择顺序链表而不采用高效的“二叉查找树“是因为，当哈希表较大而每张链表存储的数据不多时，顺序链表的效率反而更高一些。

结语：

　　同之前介绍的红黑树一样，哈希表也是一种高效的存储于查找的数据结构，特别适用于大数据的场合。至于在何时使用哈希表何时使用红黑树这个不一而论。因为，存储的效率还更数据本身相关。不过，由于哈希一向擅长处理跟字符串相关的存储，所以对于大量的字符串存储与查找可以优先考虑哈希表。