数据结构学习:哈希表

一、概念

• 哈希(Hash)表又称为散列表,是利用数组支持按照下标随机访问的特性,是数组的一种扩展,可以说没有数组就没有哈希表
• 哈希表存储键值对,key由某个散列函数转化成数组的下标,通过key访问相当于通过数组下标访问
• 可以知道数组支持下标随机访问的时间复杂度是O(1),但是为了维护连续内存空间,插入和删除的时间复杂度退化到O(n);但散列表随机访问的时间复杂度正常情况下是O(1),同时不用维护连续内存空间,插入和删除的时间复杂度也为O(1)

二、散列函数

由此可见散列函数非常重要,散列函数非常重要,一般需要满足下列几种要求

• 散列函数计算的散列值是一个非负整数(数组下标要求非负)
• 如果key1 = key2,那么hash(key1) == hash(key2)
• 如果key1 != key2,那么hash(key1) != hash(key2)

前两点要求应该是很好满足的,第三点在真实情况下几乎是不可能的,即使是业界著名的MD5、SHA等哈希算法,也无法解决这种散列冲突,而且,因为数组的存储空间有限,也会加大这种冲突的概率

三、散列冲突

正是因为散列函数无法满足上述要求,所以不可避免出现散列冲突,针对散列冲突常见的方法有开放寻址法和链表法,这里只介绍链表法,
链表法:hash(key)若相同就是哈希冲突的情况下,维护一个链表,新增的key/value有一个next指针指向上一个已经存好的key/value对,当插入的时候,只需要通过散列函数计算出相应的散列槽位即可,所以插入的时间复杂度为O(1),查找、删除的时候,若没有哈希冲突的情况,时间复杂度为O(1),若有哈希冲突,时间复杂度应与链表的长度k成正比,最坏情况下,全是哈希冲突,时间复杂度就是O(n),所以链表法的效率依赖散列函数的设计

四、代码实现

package HashTable;

public class hashtable_zhu<K,V> {
    //散列表长度
    private final static int hash_length = 8;

    //装载因子
    private final static double zzyz = 0.75f;

    //散列表初始化
    private Entry<K,V>[] table;

    public int size = 0;
    private int use = 0;

    static class Entry<K,V>{
        private K key;
        private V value;
        private Entry<K,V> next;

        public Entry(K key,V value,Entry<K,V> next){
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }

    public hashtable_zhu(){
        this.table = (Entry<K, V>[]) new Entry[hash_length];
    }

    public void put(K key,V value){
        int index = hash(key);
        //创建哨兵节点,本身不存储数据,头节点
        if (table[index] == null){
            table[index] = new Entry<>(null,null,null);
        }
        Entry<K,V> tmp = table[index];

        if (tmp.next == null){
            tmp.next = new Entry<>(key,value,null);
            size++;
            use++;
            if (use >= table.length * zzyz){
                resize();
            }
        }else{
            //哈希冲突
            do{
                tmp = tmp.next;

                if (key == tmp.key){
                    tmp.value = value;
                    return;
                }
            }while(tmp.next != null);
            //新增一个链表在前面添加节点
            Entry<K,V> temp = table[index].next;
            table[index].next = new Entry<>(key,value,temp);
            size++;
        }
    }

    private int hash(Object key) {
        int h;
        return (key == null) ? 0 : ((h = key.hashCode()) ^ (h >>> 16)) % table.length;
    }

    private void resize(){
        Entry<K,V>[] oldtable = table;   //先备份下老的
        table = new Entry[table.length * 2];
        use = 0;
        for (int i = 0; i < oldtable.length; i++){
            Entry<K,V> e = oldtable[i];
            if (e == null || e.next == null){
                continue;
            }
            while(e.next != null){
                e = e.next;
                int index = hash(e.key);
                if (table[index] == null){
                    use++;
                    table[index] = new Entry<>(null,null,null);
                }
                table[index].next = new Entry<>(e.key,e.value,table[index].next);
            }
        }
    }

    public void remove(K key){
        int index = hash(key);
        Entry<K,V> e = table[index];
        if (e == null || e.next == null){
            return;
        }

        Entry pre;
        Entry<K,V> headnode = table[index];

        do{
            pre = e;
            e = e.next;
            if (key == e.key){
                pre.next = e.next;
                size--;
                if (headnode.next == null){
                    use--;
                    return;
                }
            }
        }while(e.next != null);
    }

    public V get(K key){
        int index = hash(key);
        Entry<K,V> e = table[index];
        if (e == null || e.next == null){
            return null;
        }

        do{
            e = e.next;
            if (key == e.key){
                return e.value;
            }
        }while(e.next != null);

        return null;
    }
}