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

  1 /*************************************************************************
  2  *  Compilation:  javac SequentialSearchST.java
  3  *  Execution:    java SequentialSearchST
  4  *  Dependencies: StdIn.java StdOut.java
  5  *  Data files:   http://algs4.cs.princeton.edu/31elementary/tinyST.txt  
  6  *  
  7  *  Symbol table implementation with sequential search in an
  8  *  unordered linked list of key-value pairs.
  9  *
 10  *  % more tinyST.txt
 11  *  S E A R C H E X A M P L E
 12  *
 13  *  % java SequentialSearchST < tiny.txt 
 14  *  L 11
 15  *  P 10
 16  *  M 9
 17  *  X 7
 18  *  H 5
 19  *  C 4
 20  *  R 3
 21  *  A 8
 22  *  E 12
 23  *  S 0
 24  *
 25  *************************************************************************/
 26 
 27 /**
 28  *  The <tt>SequentialSearchST</tt> class represents an (unordered)
 29  *  symbol table of generic key-value pairs.
 30  *  It supports the usual <em>put</em>, <em>get</em>, <em>contains</em>,
 31  *  <em>delete</em>, <em>size</em>, and <em>is-empty</em> methods.
 32  *  It also provides a <em>keys</em> method for iterating over all of the keys.
 33  *  A symbol table implements the <em>associative array</em> abstraction:
 34  *  when associating a value with a key that is already in the symbol table,
 35  *  the convention is to replace the old value with the new value.
 36  *  The class also uses the convention that values cannot be <tt>null</tt>. Setting the
 37  *  value associated with a key to <tt>null</tt> is equivalent to deleting the key
 38  *  from the symbol table.
 39  *  <p>
 40  *  This implementation uses a singly-linked list and sequential search.
 41  *  It relies on the <tt>equals()</tt> method to test whether two keys
 42  *  are equal. It does not call either the <tt>compareTo()</tt> or
 43  *  <tt>hashCode()</tt> method. 
 44  *  The <em>put</em> and <em>delete</em> operations take linear time; the
 45  *  <em>get</em> and <em>contains</em> operations takes linear time in the worst case.
 46  *  The <em>size</em>, and <em>is-empty</em> operations take constant time.
 47  *  Construction takes constant time.
 48  *  <p>
 49  *  For additional documentation, see <a href="http://algs4.cs.princeton.edu/31elementary">Section 3.1</a> of
 50  *  <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne.
 51  *
 52  *  @author Robert Sedgewick
 53  *  @author Kevin Wayne
 54  */
 55 public class SequentialSearchST<Key, Value> {
 56     private int N;           // number of key-value pairs
 57     private Node first;      // the linked list of key-value pairs
 58 
 59     // a helper linked list data type
 60     private class Node {
 61         private Key key;
 62         private Value val;
 63         private Node next;
 64 
 65         public Node(Key key, Value val, Node next)  {
 66             this.key  = key;
 67             this.val  = val;
 68             this.next = next;
 69         }
 70     }
 71 
 72     /**
 73      * Initializes an empty symbol table.
 74      */
 75     public SequentialSearchST() {
 76     }
 77 
 78     /**
 79      * Returns the number of key-value pairs in this symbol table.
 80      * @return the number of key-value pairs in this symbol table
 81      */
 82     public int size() {
 83         return N;
 84     }
 85 
 86     /**
 87      * Is this symbol table empty?
 88      * @return <tt>true</tt> if this symbol table is empty and <tt>false</tt> otherwise
 89      */
 90     public boolean isEmpty() {
 91         return size() == 0;
 92     }
 93 
 94     /**
 95      * Does this symbol table contain the given key?
 96      * @param key the key
 97      * @return <tt>true</tt> if this symbol table contains <tt>key</tt> and
 98      *     <tt>false</tt> otherwise
 99      */
100     public boolean contains(Key key) {
101         return get(key) != null;
102     }
103 
104     /**
105      * Returns the value associated with the given key.
106      * @param key the key
107      * @return the value associated with the given key if the key is in the symbol table
108      *     and <tt>null</tt> if the key is not in the symbol table
109      */
110     public Value get(Key key) {
111         for (Node x = first; x != null; x = x.next) {
112             if (key.equals(x.key)) return x.val;
113         }
114         return null;
115     }
116 
117     /**
118      * Inserts the key-value pair into the symbol table, overwriting the old value
119      * with the new value if the key is already in the symbol table.
120      * If the value is <tt>null</tt>, this effectively deletes the key from the symbol table.
121      * @param key the key
122      * @param val the value
123      */
124     public void put(Key key, Value val) {
125         if (val == null) { delete(key); return; }
126         for (Node x = first; x != null; x = x.next)
127             if (key.equals(x.key)) { x.val = val; return; }
128         first = new Node(key, val, first);
129         N++;
130     }
131 
132     /**
133      * Removes the key and associated value from the symbol table
134      * (if the key is in the symbol table).
135      * @param key the key
136      */
137     public void delete(Key key) {
138         first = delete(first, key);
139     }
140 
141     // delete key in linked list beginning at Node x
142     // warning: function call stack too large if table is large
143     private Node delete(Node x, Key key) {
144         if (x == null) return null;
145         if (key.equals(x.key)) { N--; return x.next; }
146         x.next = delete(x.next, key);
147         return x;
148     }
149 
150 
151     /**
152      * Returns all keys in the symbol table as an <tt>Iterable</tt>.
153      * To iterate over all of the keys in the symbol table named <tt>st</tt>,
154      * use the foreach notation: <tt>for (Key key : st.keys())</tt>.
155      * @return all keys in the sybol table as an <tt>Iterable</tt>
156      */
157     public Iterable<Key> keys()  {
158         Queue<Key> queue = new Queue<Key>();
159         for (Node x = first; x != null; x = x.next)
160             queue.enqueue(x.key);
161         return queue;
162     }
163 
164 
165     /**
166      * Unit tests the <tt>SequentialSearchST</tt> data type.
167      */
168     public static void main(String[] args) {
169         SequentialSearchST<String, Integer> st = new SequentialSearchST<String, Integer>();
170         for (int i = 0; !StdIn.isEmpty(); i++) {
171             String key = StdIn.readString();
172             st.put(key, i);
173         }
174         for (String s : st.keys())
175             StdOut.println(s + " " + st.get(s));
176     }
177 }