1. Example: LinkedSet<T>
LinkedSet<T> Class
LinkedSet Attributes/Constructor
Linked Set Methods
LinkedSet iterator method
LinkedIterator<T> class
Reading: L&C 3rd: nd: 1

2. LinkedSet<T> Class
The LinkedSet<T> class implements the same SetADT<T> interface as ArraySet<T> using a singly linked list instead of an array
Externally, your code is not much different when using the LinkedSet<T> class instead of the ArraySet<T> class:
SetADT<String> mySet = new ArraySet<String>();
OR = new LinkedSet<String>();
Internally, method code of the LinkedSet<T> class is very different due to the difference in the underlying data structure being used. 2

3. LinkedSet<T> Class
Again: We assume that SetADT<T> interface extends Iterable. 3

4. LinkedSet Attributes/Constructor
The class definition starts with:
public class LinkedSet<T> implements SetADT<T> {
private static Random rand = new Random();
private int count;
private LinearNode<T> contents;
public LinkedSet() // default constructor
count = 0;
contents = null; // NOTE: not an array } 4

5. LinkedSet Attributes/Constructor
We don’t need to define a default capacity or pass an initial capacity to the constructor
We don’t need to instantiate an array object or any LinearNode objects in the constructor – just set contents to null 5

6. LinkedSet Methods
Note that because we are not using a fixed size data structure such as an array, we don’t need a private expandCapacity() method. 6

7. LinkedSet Methods add – O(n) public void add (T element) {
if (!contains(element))
LinearNode<T> node = new LinearNode<T>(element);
node.setNext(contents);
contents = node;
count++; } 7

8. LinkedSet Methods contains – O(n) public boolean contains (T target) {
LinearNode<T> next = contents;
while (next != null) {
if (next.getElement().equals(target)
return true;
next = next.getNext(); }
return false; 8

9. LinkedSet Methods removeRandom – O(n) not O(1) like ArraySet
public T removeRandom() throws EmptySetException {
LinearNode<T> current;
T result = null;
if (isEmpty)
throw new EmptySetException();
int choice = rand.nextInt(count) + 1; 9

10. LinkedSet Methods removeRandom (Continued)
if (choice == 1) { // remove from beginning
result = contents.getElement();
contents = contents.getNext(); }
else { // remove from middle or end
current = contents;
for (int skip = 2; skip < choice; skip++)
current = current.getNext();
result = current.getNext().getElement();
current.setNext(current.getNext().getNext());
count--;
return result;
} // bypassed LinearNode becomes garbage 10

11. LinkedSet iterator Method
iterator – O(1)
public Iterator<T> iterator {
return new LinkedIterator<T>(contents) }
We will study the LinkedIterator class to understand how it is implemented 11

12. LinkedIterator<T> Class
We may have several collection classes like the LinkedSet class that use an underlying singly linked linear data structure
Again, we would like to reuse one Iterator class for all of these collection classes
So we write a general purpose Iterator class for use with linked data structures 12

13. LinkedIterator<T> Class
The iterator method of the LinkedSet class instantiates and returns a reference to a LinkedIterator object to its caller
The LinkedIterator constructor needs to get a reference to the first LinearNode object in the specific linked structure to be iterated 13

14. LinkedIterator<T> Class
Class / Attribute Definitions and Constructor
public class LinkedIterator<T>
implements Iterator<T> {
private LinearNode<T> current; // current position
public LinkedIterator(LinearNode<T> current)
this.current = current; } 14

15. LinkedIterator Methods
hasNext – O(1)
public boolean hasNext() {
return current != null; }
next – O(1)
public T next()
if (!hasNext())
throw new NoSuchElementException();
T result = current.getElement();
current = current.getNext();
return result;
} // old LinearNode does not become garbage (Why?) 15

16. LinkedIterator Methods
remove – O(1)
We don’t need to implement real code for the remove method, but there is no return value that we can use to indicate that it is not implemented
If we don’t implement it, we indicate that the code is not implemented by throwing an exception
public void remove() throws UnsupportedOperationException {
throw new UnsupportedOperationException(); } 16

17. LinkedIterator Methods
Again, if we implement the remove method, notice that we don’t specify the element that is to be removed and we do not return a reference to the element being removed
It is assumed that the calling code has been iterating on condition hasNext() and calling next() and already has a reference
The last element returned by next() is the element that will be removed 17

18. LinkedIterator Method Analysis
All three LinkedIterator methods are O(1)
However, they are usually called inside an external while loop or “for-each” loop
Hence, the process of “iterating” through a collection using an Iterator is O(n) 18

19. LinkedIterator Class in Text
There is an anomaly in the definition of the LinkedIterator class in the textbook
The class has a count attribute and the constructor has a parameter to set count
But that attribute is not used anywhere in the code of the other methods
The code can and does always identify the end of the list by the null terminator value
Why was count included? 19

20. LinkedSet Alternative
If the count attribute was of no use in the LinkedIterator class, is it also of no use in the LinkedSet class?
It is possible to implement the code of the LinkedSet class without a count attribute
What is adversely affected by removing it?
Size method would become O(n) instead of O(1)
RemoveRandom method would need to use size method to calculate its choice of node to remove, but it is already O(n) 20