ArraySet Methods and ArrayIterator

1. 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

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: nto 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) 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