算法4-6：关联数组的基本实现

本节主要介绍键值对表的基本实现方法。

链表法

一种方法就是用链表进行实现。这种方法的基本思想就是用链表储存键值对。当需要寻找一个值时，扫描整个链表，如果有匹配的键，就返回对应的值。当需要插入一个值时，扫描整个链表，如果能够找到匹配的键，就覆盖对应的值，如果没有找到，就在链表的头部增加一个新的键值对。

这种算法查找操作和插入操作的复杂度均为N，性能很差。

代码

public class LinkedST<Key extends Comparable<Key>,Value> {
    private class Node {
        Key key;
        Value value;
        Node next;
    }
 
    private Node first;
 
    public void insert(Key key, Value value) {
        Node node = search(key);
        if(node == null) {
            node = new Node();
            node.key = key;
            node.value = value;
            node.next = first;
            first = node;
        } else {
            node.value = value;
        }
    }
 
    public boolean isEmpty() {
        return first == null;
    }
 
    public Value get(Key key) {
        Node node = search(key);
        if(node != null)
            return node.value;
        return null;
    }
 
    private Node search(Key key) {
        Node node = first;
        while(node != null) {
            if(node.key.compareTo(key) == 0) {
                return node;
            }
            node = node.next;
        }
        return null;
    }
}

数组法

另一种方法就是用数组进行实现。搜索的时候可以用二分查找。所以这种算法查找的复杂度时logN，但是插入的复杂度依然是N。虽然比链表稍微好一点，但是插入操作的复杂度还是太高，无法满足性能要求。

代码

public class ArrayST<Key extends Comparable<Key>, Value> {
    private Key[] keys; // 注意，这里必须要两个数组分别保存key和value。如果将key和value包含在一个对象中，会导致Generic Array Creation。
    private Value[] values;
    private int N;
 
    public ArrayST(int capacity) {
        keys = (Key[])new Comparable[capacity];
        values = (Value[])new Object[capacity];
    }
 
    private void debugPrint() {
        for(int i=0;i<N;i++) {
            System.out.println(keys[i]);
        }
    }
 
    public void insert(Key key, Value value) {
        int i = search(key);
 
        // 如果找到了对应的关键字
        if(i < N && keys[i].compareTo(key) == 0) {
            // 覆盖对应的值
            values[i] = value;
        } else {
            // 插入新的值
            for(int j=N-1;j>=i;j--) {
                keys[j+1] = keys[j];
                values[j+1] = values[j];
            }
            keys[i] = key;
            values[i] = value;
            N++;
        }
    }
 
    public Value get(Key key) {
        int i = search(key);
 
        // 如果找到了对应的键
        if(i<N && keys[i].compareTo(key) == 0) {
            return values[i];
        }
 
        // 找不到
        return null;
    }
 
    public boolean isEmpty() {
        return N==0;
    }
 
    // 二分查找
    private int search(Key key) {
        int lo = 0;
        int hi = N;
        while(lo < hi) { // 注意，这里是lo < hi，而不是lo > hi
            int mid = (hi-lo)/2 + lo;
            int compare = key.compareTo(keys[mid]);
 
            // 如果key比较小，说明要找的键在左边
            if(compare < 0) {
                hi = mid;
            } else if(compare > 0) {
                // 要找的键在右边
                lo = mid+1;
            } else {
                // 正好找到想要的键
                return mid;
            }
        }
 
        // 没有找到，注意：没有找到时要返回key应该插入的位置，而不是N
        return lo;
    }
}

结论

因此需要一种算法能够实现查找和插入操作的复杂度都很低。