-
Notifications
You must be signed in to change notification settings - Fork 1
/
SequentialSearchST.cs
201 lines (178 loc) · 6.73 KB
/
SequentialSearchST.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
/******************************************************************************
* SequentialSearchST.java
* §3.1 Elementary Symbol Tables.
* <a href="http://algs4.cs.princeton.edu/31elementary">Section 3.1</a>
* Sequential search in an unordered linked list
* Symbol table implementation with sequential search in an unordered linked list of key-value pairs.
* Copyright © 2000–2016, Robert Sedgewick and Kevin Wayne.
* Last updated: Wed Nov 2 05:20:57 EDT 2016.
* https://algs4.cs.princeton.edu/31elementary/SequentialSearchST.java.html
*
******************************************************************************/
namespace SedgewickWayne.Algorithms
{
using System;
using System.Collections;
using System.Collections.Generic;
/**
* The {@code SequentialSearchST} class represents an (unordered) symbol table of generic key-value pairs.
* It supports the usual put, get, contains,
* delete, size, and is-empty methods.
* It also provides a keys method for iterating over all of the keys.
* A symbol table implements the associative array 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 {@code null}.
* Setting the value associated with a key to {@code null} is equivalent to deleting the key from the symbol table.
* This implementation uses a singly-linked list and sequential search.
* It relies on the {@code equals()} method to test whether two keys are equal.
* It does not call either the {@code compareTo()} or {@code hashCode()} method.
* The put and delete operations take linear time;
* the get and contains operations takes linear time in the worst case.
* The size, and is-empty operations take constant time.
* Construction takes constant time.
**/
public class SequentialSearchST<TKey, TValue>
: ISymbolTable<TKey, TValue>
where TKey : IComparable<TKey>, IEquatable<TKey>
{
private int n; // number of key-value pairs
private Node first; // the linked list of key-value pairs
/* Returns the number of key-value pairs in this symbol table. */
public int Size => n;
/* Returns true if this symbol table is empty. */
public bool IsEmpty => n == 0;
// a helper linked list data type
class Node
{
internal TKey key;
internal TValue val;
internal Node next;
public Node(TKey key, TValue val, Node next)
{
this.key = key;
this.val = val;
this.next = next;
}
}
/**
* Initializes an empty symbol table.
*/
public SequentialSearchST() { }
/**
* Returns true if this symbol table contains the specified key.
*
* @param key the key
* @return {@code true} if this symbol table contains {@code key};
* {@code false} otherwise
* @throws ArgumentNullException if {@code key} is {@code null}
*/
public bool Contains(TKey key)
{
ThrowException(key, nameof(Contains));
return Get(key) != null;
}
/**
* Returns all keys in the symbol table as an {@code Iterable}.
* To iterate over all of the keys in the symbol table named {@code st},
* use the foreach notation: {@code for (TKey key : st.keys())}.
*
* @return all keys in the symbol table
*/
public IEnumerable<TKey> Keys()
{
Queue<TKey> queue = new Queue<TKey>();
for (Node x = first; x != null; x = x.next)
queue.Enqueue(x.key);
return queue;
}
/**
* Returns the value associated with the given key in this symbol table.
*
* @param key the key
* @return the value associated with the given key if the key is in the symbol table
* and {@code null} if the key is not in the symbol table
* @throws ArgumentNullException if {@code key} is {@code null}
*/
public TValue Get(TKey key)
{
ThrowException(key, nameof(Get));
for (Node x = first; x != null; x = x.next)
{
if (key.Equals(x.key))
return x.val;
}
return default(TValue);
}
/**
* Inserts the specified key-value pair into the symbol table, overwriting the old
* value with the new value if the symbol table already contains the specified key.
* Deletes the specified key (and its associated value) from this symbol table
* if the specified value is {@code null}.
*
* @param key the key
* @param val the value
* @throws ArgumentNullException if {@code key} is {@code null}
*/
public void Put(TKey key, TValue val)
{
ThrowException(key, nameof(Put));
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 specified key and its associated value from this symbol table
* (if the key is in this symbol table).
*
* @param key the key
* @throws ArgumentNullException if {@code key} is {@code null}
*/
public void Delete(TKey key)
{
ThrowException(key, nameof(Delete));
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, TKey key)
{
if (x == null) return null;
if (key.Equals(x.key))
{
n--;
return x.next;
}
x.next = Delete(x.next, key);
return x;
}
public IEnumerator<TKey> GetEnumerator()
{
return Keys().GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return Keys().GetEnumerator();
}
private void ThrowException(TKey key, string method)
{
if (key == null)
{
throw new ArgumentNullException($"Argument key to {method} is null");
}
}
}
}