算法_散列表

　　使用散列的查找算法分为两步,第一步用散列函数将被查找的键转化为数组的一个索引,理想情况下不同的键都被转化为不同的索引值.而当多个键散列到相同的索引值的情况下,就需要处理碰撞冲突,为此有两种方法,拉链法和线性探测法.

　　散列函数用于通过键来获取其对应的索引值.好的散列函数应该具有计算简便,等价的键必然产生相等的散列值,均匀的散列所有的键的条件.

　　一.基于拉链法的散列表.

　　拉链法对于碰撞处理的解决方法是将大小为M的数组中的每个元素都指向一个链表,链表中的每一个节点都存储了散列值为该元素的索引的键值对.查找分两步:首先根据散列值找到对应的链表,然后沿着链表顺序查找相应的键.用M条链表保存N个键,链表的平均长度为N/M.代码实现如下:

public class SeparateChainingHashST<Key,Value> {
    private int N;            //键值对总数
    private int M;            //散列表大小
    private SequentialSearchST<Key,Value>[] st;
    public SeparateChainingHashST() {
        this(997);
    }
    public SeparateChainingHashST(int M) {
        //创建M条链表.
        this.M=M;
        st=(SequentialSearchST<Key,Value>[])new SequentialSearchST[M];
        for (int i = 0; i < M; i++) {
            st[i]=new SequentialSearchST();//创建链表
        }
    }
    private int hash(Key key) {
        return (key.hashCode()&0x7fffffff)%M;
    }
    public Value get(Key key) {
        return (Value)st[hash(key)].get(key);
    }
    public void put(Key key,Value val) {
        st[hash(key)].put(key, val);
    }
}
//链表
class SequentialSearchST<Key,Value> {
        private Node first;     //链表首节点
        private class Node {
            Key key;
            Value val;
            Node next;
            public Node(Key key,Value val,Node next) {
                this.key=key;
                this.val=val;
                this.next=next;
            }
        }
        public Value get(Key key) {
            for(Node x=first;x!=null;x=x.next) {
                if(key.equals(x.key)) {
                    return x.val;
                }

            }
            return null;
        }
        public void put(Key key,Value val) {
            for (Node x=first;x!=null;x=x.next) {
                if(key.equals(x.key)) {
                    x.val=val;
                    return;
                }
                first=new Node(key,val,first);
            }
        }
    }

　　二.基于线性探测法的散列表

　　实现散列表的第二种形式就是用大小为M的数组保存N个键值对,其中M>N.依靠数组的空位来解决碰撞冲突.当碰撞发生的时候,直接检查散列表的下一个位置,并将索引加1.我们用散列函数找到键在数组的索引,判断键是否和被查找的键相同,如果不同则继续查找,直到找到该键或者遇到一个空元素.代码实现如下(其中需要动态的调整数组的大小以提高查找效率)

public class LinearProbingHashST<Key,Value> {
    private int N;        //符号表中的键值对的总数
    private int M=16;    //线性探测表的大小
    private Key[] keys;    //键
    private Value[] vals;//值
    public LinearProbingHashST() {
        keys=(Key[]) new Object[M];
        vals=(Value[]) new Object[M];
    }
    public LinearProbingHashST(int x) {
        M=x;
        keys=(Key[]) new Object[M];
        vals=(Value[]) new Object[M];
    }
    private int hash(Key key) {
        return (key.hashCode()&0x7fffffff)%M;
    }
    private void resize(int cap) {
        LinearProbingHashST<Key, Value> t;
        t=new LinearProbingHashST<>(cap);
        for(int i=0;i<M;i++) {
            if(keys[i]!=null)
                t.put(keys[i], vals[i]);
        }
        keys=t.keys;
        vals=t.vals;
        M=t.M;
    }
    //实现动态的调整数组大小
    public void put(Key key,Value val) {
        if(N>=M/2) resize(2*M);
        int i;
        for(i=hash(key);keys[i]!=null;i=(i+1)%M) {
            if(keys[i].equals(key)) {
                vals[i]=val;
                return ;
            }
        }
        keys[i]=key;
        vals[i]=val;
        N++;
    }
    public Value get(Key key) {
        for(int i=hash(key);keys[i]!=null;i=(i+1)%M) {
            if(keys[i].equals(key))
                return vals[i];
        }
        return null;
    }
    /*
     * 删除元素不能直接设为null
     * 因为会影响到后续元素的查找,方法是将后面的元素重新插入数组.
     * */
    public void delete(Key key) {
        if(!contains(key)) return;
        int i=hash(key);
        while(!key.equals(keys[i]))
            i=(i+1)%M;
        keys[i]=null;
        vals[i]=null;
        i=(i+1)%M;
        while(keys[i]!=null) {
            Key keyToRedo=keys[i];
            Value valToRedo=vals[i];
            keys[i]=null;
            vals[i]=null;
            N--;
            put(keyToRedo,valToRedo);
            i=(i+1)%M;
        }
        N--;
        if(N>0&&N==M/8) resize(M/2);
    }
    public boolean contains(Key key) {
        for(Key okey:keys) {
            if(key.equals(okey))
                return true;
        }
        return false;
    }
}