符号表听不懂，但有个更简单的名字——字典。主要目的就是将一个键和一个值联系起来。我们通过查询键来找到对应的值。

符号表是一种存储键值对的数据结构，支持插入和查找操作。

符号表中不允许重复的键，当重复的时候新值会代替旧值。

键不能空。

链表的形式实现符号表

平均成本（查找 N/2 插入N）

public class SequentialSearchST<Key,Value> {
    private Node first;
    private class Node{   //结点，存放键值对和下一个结点指针
        Key key;
        Value val;
        Node next;
    public Node(Key k,Value v,Node n) {
        key=k;
        val=v;
        this.next=n;
    }
  }
    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);  //否则就新建一个结点
    }   
}

用数组实现有序序号表

平均成本（查找 lgN 插入N）

public class BinarySearchST<Key extends Comparable<Key>,Value> {
    private Key[]keys;
    private Value[]vals;
    private int N;
    public BinarySearchST(int a) {
        keys=(Key[])new Comparable[a];
        vals=(Value[])new Object[a];
    }
    public int size() {
        return N;
    }
    public boolean isEmpty() {
        return N==0;
    }
    public int rank(Key key)  {   //二分查找 这是有序的
        int lo=0,hi=N-1;
        while(lo<=hi) {
            int mid=lo+(hi-lo)/2;
            int cmp=key.compareTo(keys[mid]);
            if(cmp<0) hi=mid-1;
            else if(cmp>0) lo=mid+1;
            else return mid;
        }
        return lo;
    }

    public Value get(Key key) {
        if(isEmpty())return null;
        int i=rank(key);
        if(i<N&&keys[i].compareTo(key)==0)return vals[i];
        else return null;
    }
    public void put(Key key,Value val) {
        int i=rank(key);                   //二分法找序号
        if(i<N&&keys[i].compareTo(key)==0) {
            vals[i]=val; return;          
        }
        for(int j=N;j>i;j--) {          //序号i之后的元素往后移动一格
            keys[j]=keys[j-1];
            vals[j]=vals[j-1];
        }
        keys[i]=key;
        vals[i]=val;
        N++;
    }


    public Key min() {  //返回最小值
        return keys[0];
    }
    public Key max() {
        return keys[N-1];
    }
    public Key select(int k) {
        return keys[k];
    }
    public Key ceiling(Key key) {     //返回key对应的值
        int i=rank(key);
        return keys[i];
    }

}