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

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.

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

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

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

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

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

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

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 }

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; }

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

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); }

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();

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; }

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)!

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

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

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