[数据结构] 直接寻址表

当关键字的全域U比较小时，直接寻址是一种简单而有效的技术。假设某应用要用到一个动态集合，其中每个元素都是取自全域U={0, 1, …, m - 1}中的一个关键字，这里m不是一个很大的数。别外，假设没有两个元素具有相同的关键字。

为表示动态集合，我们用一个数组，或称为直接寻址表(direct-address table)，记为T[0..m-1]。其中每个位置，或称为槽(slot)，对应全域U中的一个关键字。图11-1描绘了该方法。槽
k指向集合中一个关键字为k的元素。如果该集合中没有关键字为k的元素，则T[k] = NIL。

字典操作

几个字典操作实现起来比较简单

DIRECT-ADDRESS-SEARCH(T, k)
    return T[k]

DIRECT-ADDRESS-INSERT(T, x)
    T[x.key] = x

DIRECT-ADDRESS-DELETE(T, x)
    T[x.key] = NIL

上述的每一个操作都只需O(1)时间。

对于某些应用，直接寻址表本身就可以存放动态集合中的元素。也就是说，并不把每个元素的关键字及其卫星数据都放在直接寻址表外部的一个对象中，再由表中某个槽的指针指向该对象，而是直接把该对象存放在表的槽中，从而节省了空间。我们使用对象内的一个特殊关键字来表明该槽为空槽。而且，通常不必存储该对象的关键字属性，因为如果知道一个对象在表中的下标，就可以得到它的关键字。然而，如果不存储关键字，我们就必须有某种方法来确定某个槽是否为空。

自己的实现（Java)

参考了HashMap的部分代码

public class DirectAddressMap<K, V> {
    private Entry<K, V>[] table;

    private static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    private int capacity;

    public DirectAddressMap(int capacity) {
        this.table = new Entry[capacity];
        this.capacity = capacity;
    }

    public DirectAddressMap(){
        this.table = new Entry[DEFAULT_INITIAL_CAPACITY];
        this.capacity = DEFAULT_INITIAL_CAPACITY;
    }
    private int hash(K key){
        int hash = key.hashCode() % DEFAULT_INITIAL_CAPACITY;
        return hash;
    }

    //相当于DIRECT-ADDRESS-INSERT
    public V put(K key, V value){
        int hash = hash(key);

        Entry<K, V> entry = new Entry<K, V>(hash, key, value, null);
        table[hash] = entry;
        return value;

    }

    //相当于DIRECT-ADDRESS-SEARCH
    public V get(K key){
        int hash = hash(key);
        Entry<K, V> kvEntry = table[hash];
        if(kvEntry == null){
            return null;
        }
        return kvEntry.getValue();
    }

    //相当于DIRECT-ADDRESS-DELETE
    public V remove(K k){
        int hash = hash(k);
        V v = get(k);
        table[hash] = null;

        return v;
    }

    //节点
    private static class Entry<K, V>{
        final int hash;
        final K key;
        V value;
        Entry<K,V> next;

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

        public final K getKey(){
            return  key;
        }

        public final V getValue(){
            return value;
        }

        public final String toString(){
            return key + "=" + value;
        }

        public final int hashCode(){
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue){
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

    }
}

练习

11.1-1假设一动态集合S用一个长度为m的直接寻址表T来表示。请给出一个查找S中最大元素的过程。你所给的过程在最坏情况下的运行时间是多少

答：
    最坏情况下需要遍历整个直接寻址表T
    所以最坏情况下的运行时间为Θ(m)

参考

算法导论11.2散列表