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://www.mamicode.com/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 key107      * @return the value associated with the given key if the key is in the symbol table108      *     and <tt>null</tt> if the key is not in the symbol table109      */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 value119      * 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 key122      * @param val the value123      */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 table134      * (if the key is in the symbol table).135      * @param key the key136      */137     public void delete(Key key) {138         first = delete(first, key);139     }140 141     // delete key in linked list beginning at Node x142     // warning: function call stack too large if table is large143     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 }