《Algorithms 4th Edition》读书笔记——3.1 符号表(Elementary Symbol Tables)-Ⅳ

3.1.4 无序链表中的顺序查找

符号表中使用的数据结构的一个简单选择是链表，每个结点存储一个键值对，如以下代码所示。get()的实现即为遍历链表，用equals()方法比较需被查找的键和每个节点中的键。如果匹配成功我们就返回null。put()的实现也是遍历链表，用equals()方法比较需被查找的键。如果匹配成功我们就用第二个参数指定的值更新和改键现关联的值，否则我们就用给定的键值对创建一个新的节点并将其插入到链表的开头。这种方法也被称为顺序查找：在查找中我们一个一个地顺序遍历符号表中的所有键并使用equals()方法来寻找与被查找的键匹配的键。

算法（SequentialSearchST）用链表实现了符号表的基本API，这里我们将size()、keys()和即时型的delete()方法留作联系。

 /*************************************************************************
  *  Compilation:  javac SequentialSearchST.java
  *  Execution:    java SequentialSearchST
  *  Dependencies: StdIn.java StdOut.java
  *  Data files:   http://algs4.cs.princeton.edu/31elementary/tinyST.txt
  *
  *  Symbol table implementation with sequential search in an
  *  unordered linked list of key-value pairs.
  *
  *  % more tinyST.txt
  *  S E A R C H E X A M P L E
  *
  *  % java SequentialSearchST < tiny.txt
  *  L 11
  *  P 10
  *  M 9
  *  X 7
  *  H 5
  *  C 4
  *  R 3
  *  A 8
  *  E 12
  *  S 0
  *
  *************************************************************************/

 /**
  *  The <tt>SequentialSearchST</tt> class represents an (unordered)
  *  symbol table of generic key-value pairs.
  *  It supports the usual <em>put</em>, <em>get</em>, <em>contains</em>,
  *  <em>delete</em>, <em>size</em>, and <em>is-empty</em> methods.
  *  It also provides a <em>keys</em> method for iterating over all of the keys.
  *  A symbol table implements the <em>associative array</em> abstraction:
  *  when associating a value with a key that is already in the symbol table,
  *  the convention is to replace the old value with the new value.
  *  The class also uses the convention that values cannot be <tt>null</tt>. Setting the
  *  value associated with a key to <tt>null</tt> is equivalent to deleting the key
  *  from the symbol table.
  *  <p>
  *  This implementation uses a singly-linked list and sequential search.
  *  It relies on the <tt>equals()</tt> method to test whether two keys
  *  are equal. It does not call either the <tt>compareTo()</tt> or
  *  <tt>hashCode()</tt> method.
  *  The <em>put</em> and <em>delete</em> operations take linear time; the
  *  <em>get</em> and <em>contains</em> operations takes linear time in the worst case.
  *  The <em>size</em>, and <em>is-empty</em> operations take constant time.
  *  Construction takes constant time.
  *  <p>
  *  For additional documentation, see <a href="http://algs4.cs.princeton.edu/31elementary">Section 3.1</a> of
  *  <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
  *
  *  @author Robert Sedgewick
  *  @author Kevin Wayne
  */
 public class SequentialSearchST<Key, Value> {
     private int N;           // number of key-value pairs
     private Node first;      // the linked list of key-value pairs

     // a helper linked list data type
     private class Node {
         private Key key;
         private Value val;
         private Node next;

         public Node(Key key, Value val, Node next)  {
             this.key  = key;
             this.val  = val;
             this.next = next;
         }
     }

     /**
      * Initializes an empty symbol table.
      */
     public SequentialSearchST() {
     }

     /**
      * Returns the number of key-value pairs in this symbol table.
      * @return the number of key-value pairs in this symbol table
      */
     public int size() {
         return N;
     }

     /**
      * Is this symbol table empty?
      * @return <tt>true</tt> if this symbol table is empty and <tt>false</tt> otherwise
      */
     public boolean isEmpty() {
         return size() == 0;
     }

     /**
      * Does this symbol table contain the given key?
      * @param key the key
      * @return <tt>true</tt> if this symbol table contains <tt>key</tt> and
      *     <tt>false</tt> otherwise
      */
     public boolean contains(Key key) {
         return get(key) != null;
     }

     /**
      * Returns the value associated with the given key.
      * @param key the key
      * @return the value associated with the given key if the key is in the symbol table
      *     and <tt>null</tt> if the key is not in the symbol table
      */
     public Value get(Key key) {
         for (Node x = first; x != null; x = x.next) {
             if (key.equals(x.key)) return x.val;
         }
         return null;
     }

     /**
      * Inserts the key-value pair into the symbol table, overwriting the old value
      * with the new value if the key is already in the symbol table.
      * If the value is <tt>null</tt>, this effectively deletes the key from the symbol table.
      * @param key the key
      * @param val the value
      */
     public void put(Key key, Value val) {
         if (val == null) { delete(key); return; }
         for (Node x = first; x != null; x = x.next)
             if (key.equals(x.key)) { x.val = val; return; }
         first = new Node(key, val, first);
         N++;
     }

     /**
      * Removes the key and associated value from the symbol table
      * (if the key is in the symbol table).
      * @param key the key
      */
     public void delete(Key key) {
         first = delete(first, key);
     }

     // delete key in linked list beginning at Node x
     // warning: function call stack too large if table is large
     private Node delete(Node x, Key key) {
         if (x == null) return null;
         if (key.equals(x.key)) { N--; return x.next; }
         x.next = delete(x.next, key);
         return x;
     }

     /**
      * Returns all keys in the symbol table as an <tt>Iterable</tt>.
      * To iterate over all of the keys in the symbol table named <tt>st</tt>,
      * use the foreach notation: <tt>for (Key key : st.keys())</tt>.
      * @return all keys in the sybol table as an <tt>Iterable</tt>
      */
     public Iterable<Key> keys()  {
         Queue<Key> queue = new Queue<Key>();
         for (Node x = first; x != null; x = x.next)
             queue.enqueue(x.key);
         return queue;
     }

     /**
      * Unit tests the <tt>SequentialSearchST</tt> data type.
      */
     public static void main(String[] args) {
         SequentialSearchST<String, Integer> st = new SequentialSearchST<String, Integer>();
         for (int i = 0; !StdIn.isEmpty(); i++) {
             String key = StdIn.readString();
             st.put(key, i);
         }
         for (String s : st.keys())
             StdOut.println(s + " " + st.get(s));
     }
 }

这种基于链表的实现能够用于和我们的用例类似的、需要大型符号表的应用？我们已经说过，分析符号表算法比分析排序算法更加困难，因为不同的用例所进行的操作序列各不相同。对于FrequencyCounter，最常见的情形是虽然查找和插入的使用模式是不可预测的，但他妈的使用肯定不是随机的。因此我们主要研究最坏情况下的性能。为了方便，我们使用命令中表示一次成功的查找来命中表示一次失败的查找。使用基于链表的符号表的索引引用例的轨迹如下图。

符号表的实现是i用了一个私有内部Node类来在链表中保存键和值。get()的实现会顺序地搜索链表查找给定的键（找到则返回相关联的值）。put()的实现也会顺序地搜索链表查找给定的键，如果找到则更新相关联的值，否则它会用给定的键值对创建一个新的结点并将其插入到链表的开头。size()、keys()和即时型的delete()方法的实现自行练习。

---

命题A。在含有N对键值的基于（无序）链表的符号表中，未命中的查找和插入操作都需要N次比较。未命中的查找和插入都需要N次比较。命中的查找在最坏情况下需要N次比较。特别地，向一个空表中插入N个不用的键余姚~N^2 / 2次比较。

证明。在表中查找一个不存在的键时，我们会将表中的每个键和给定的键比较。因为不允许出现重复的键，每次插入操作之前我们都需要这样查找一遍。

推论想空表中插入N个不同的键需要~N^2 / 2次比较。