1. ArraySet Methods and ArrayIterator
Homework review
ArraySet and ArrayIterator Methods with Big-O analysis
Reading: L&C 3rd ed:15.3, Pages nd ed: 3.6. (Book has some mistakes.) 1

2. Problem size parameter
In analyzing the time complexity of the operations of the ArraySet class we need to choose the parameters which specifies the size of our problem.
We choose the size of the set: n to be the parameter. Then, we analyze the time complexity of ArraySet with respect to changes in the size of the set.
In Big-O analysis we always consider the worst case.

3. ArrayIterator Methods
Default constructor should NOT be used
May want to include this code to prevent any calls to the default constructor:
private ArrayIterator() { }
Overloaded Constructor:
public ArrayIterator(T[] collection, int count) {
items = collection; // NOTE: creates an alias
// not a new array
this.count = count;
current = 0; } 3

4. ArrayIterator Methods
hasNext – O(1)
public boolean hasNext() {
return current < count; }
next – O(1)
public T next()
if (!hasNext())
throw new NoSuchElementException();
return items[current++]; 4

5. ArrayIterator 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(); } 5

6. ArrayIterator Methods
If we do 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 6

7. ArrayIterator Method Analysis
All three ArrayIterator 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) 7

8. ArraySet Methods size - O(1) isEmpty – O(1) public int size() {
return count; }
isEmpty – O(1)
public boolean isEmpty()
return count == 0;

9. ArraySet Methods expandCapacity – O(n) private void expandCapacity() {
T[] larger =
(T[]) new Object[2 * contents.length];
for (int i = 0; i < contents.length; i++)
larger[i] = contents[i];
contents = larger; // original array
// becomes garbage }

10. ArraySet Methods
contains – O(n): The code is a bit different than the one used in the book (both O(n)).
public boolean contains(T target) {
for (T element : contents)
if (target.equals(element))
return true;
return false; }

11. ArraySet Methods add – O(n) public void add (T element) {
if (!contains(element))
if (size() == contents.length)
expandCapacity();
contents[count] = element;
count++; }

12. ArraySet Methods addAll – O( (2n + m).m)
(Note: We also can code addAll using a for- each loop because we added extends Iterable to SetADT interface definition)
public void addAll(setADT<T> set) {
for(T element : set)
add(element); }

13. ArraySet Methods remove – O(n) public T remove(T target) throws
EmptySetException, NoSuchElementException {
if (isEmpty())
throw new EmptySetException();
for (int i = 0; i < count; i++) {
if (contents[i].equals(target)) {
T result = contents[i];
contents[i] = contents[--count];
contents[count] = null;
return result; }
throw new NoSuchElementException();

14. ArraySet Methods removeRandom – O(1) public T removeRandom()
throws EmptySetException {
if (isEmpty())
throw new EmptySetException();
int choice = rand.nextInt(count);
T result = contents[choice];
contents[choice] = contents[count-1];
contents[count-1] = null;
count--;
return result; }

15. ArraySet Methods removeRandom (Bad Alternative?)
We may want to avoid some duplicate code in the removeRandom method and make it shorter.
Throws any EmptySetException that occurs in remove
public T removeRandom() throws EmptySetException {
return remove(contents[rand.nextInt(count)]); }
The above alternative algorithm is O(n) instead of O(1)!

16. ArraySet Methods union:
this set size: n parameter set size m public SetADT<T> union (SetADT<T> set) {
ArraySet<T> both = new ArraySet<T>();
both.addAll(this);//O((0+n).n)=O(n.n)
both.addAll(set); //O((2n+m).m)
return both; }
O(n.n) + O((2n+m).m) = O(n.n + 2m.n + m.m) 16

17. ArraySet Methods toString – O(n) public String toString() {
String result = “”;
for (T obj : contents) {
if (obj == null) // first null is at count
return result;
result += obj + “\n”; }
return result; // exactly full – no nulls 17

18. ArraySet Methods iterator – O(1) public Iterator<T> iterator() {
return
new ArrayIterator<T>(contents, count); } 18