Lecture G - Collections

1. Lecture G - Collections Unit G1 – Abstract Data Types

2. Collections Array-based implementations of simple collection abstract data types

3. Collection data types • Very often one creates objects that hold collections of items. • Each type of collection has rules for accessing the elements in it • Array: the items are indexed by integers, and each item can be accessed according to its index • Set: the items are un-ordered and appear at most once, and items are accessed according to their value • Map (dictionary, associative array): the items are indexed by keys, and each item can be accessed according to its key • Queue: the items are ordered and can be accessed only in FIFO order (first in first out) • Stack: the items are ordered and can be accessed only in LIFO order (last in first out)

4. Abstract data types • Data types are defined abstractly: what operations they support. • Each data type can be implemented in various different ways • Each implementation has its own data structure • Implementations may differ in their efficiency for various operations or in their storage requirements • This is the standard dichotomy of interface vs. implementations • In this course we will only look at very simple implementations of basic abstract data types

5. The Set abstract data type • A Set is an un-ordered collection of items with no duplicates allowed. It supports the following operations: • Create an empty Set • Add an item to the set • Delete an item form the set • Check whether an item is in the set • We will exhibit an implementation using an array to hold the items • Our solution will be for a set of integers • Generic solutions are also possible • This implementation is not efficient

6. Set public class Set { // The elements of this set, in no particular order private int[] elements; // The number of elements in this set private int size; private final DEFAULT_LENGTH = 100; public Set(int maxSize) { elements = newint[maxSize]; size=0; } public Set() { this(DEFAULT_LENGTH);}

7. Set methods public boolean contains (int x) { for(int j=0 ; j<size ; j++) if ( elements[j] == x) returntrue; returnfalse; } publicvoid insert(int x) { if ( !contains(x) ) elements[size++] = x; } publicvoid delete(int x){ for(int j=0 ; j<size ; j++) if ( elements[j] == x) { elements[j] = elements[--size]; return; } }

8. Set – resizing on overflow publicvoid safeInsert(int x) { if ( !contains(x) ) { if (size == elements.length) resize(); elements[size++] = x; } } private void resize() { int[] temp = newint[2*elements.length]; for (int j=0 ; j<size ; j++) temp[j] = elements[j]; elements = temp; }

9. Set – variants for union methods publicvoid insertSet(Set s) { for (int j= 0 ; j < s.size ; j++) insert(s.elements[j]); } public Set union(Set s} { Set u = new Set(size +s.size ); u.insertSet(this); u.insertSet(s); return u; } public static Set union(Set s, Set t) { return s.union(t); }

10. Immutable Set • An immutable object type is an object that can not be changed after its construction • An immutable set does not support the insert and delete operations • Instead, its constructor will receive an array of the elements in the set • It only supports the contains predicate • We will show an efficient implementation for immutable sets • contains() will use binary search • contains() will require only O(log N) time

11. ImmutableSet publicclass ImmutableSet { /** The elements of this set, ordered from lowest to * highest */ privateint[] elements; /** The elements given as the parameter do not have * to be ordered. We do assume that there are no * duplicates. */ public ImmutableSet(int[] elements) { this.elements = newint[elements.length]; for(int j=0 ; j < elements.length;j++) this.elements[j]=elements[j]; MergeSort.mergeSort(this.elements); }

12. ImmutableSet – binary search publicboolean contains (int x) { return contains(x, 0, elements.length - 1); } private boolean contains(int x, int low, int high){ if (low > high) returnfalse; int med = (low + high) / 2; if (x == elements[med]) return true; else if (x < elements[med]) return contains(x, low, med-1); else return contains(x, med+1, high); }

13. Lecture G - Collections Unit G2 - Stacks

14. Stacks How to use and implement stacks

15. The Stack data type • A stack holds an ordered collection of items, items can be accessed only in first-in-last-out order • Its operations are: • Create an empty stack • Push an item into the stack • Pop an item from the stack – removes (and returns) the last item that was pushed onto the stack • Check whether the stack it empty or not • Used in many aspects of implementation of high level programming languages • Most CPUs support stacks in hardware

16. Stack sample run • Create empty stack { } • Push 5 { 5 } • Push 4 { 5 4 } • Push 8 { 5 4 8 } • Pop (returns 8) { 5 4 } • Push 7 { 5 4 7 } • Pop (returns 7) { 5 4 } • Pop (returns 4) { 5 }

17. Evaluating expressions • 5 * (( 6 + 3) / ( 7 – 2 * 2)) • Push 5 { 5 } • Push 6 { 5 6 } • Push 3 { 5 6 3 } • + push( pop() + pop() ) { 5 9 } • Push 7 { 5 9 7 } • Push 4 { 5 9 7 2 } • Push 1 { 5 9 7 2 2 } • * push( pop() * pop() ) { 5 9 7 4 } • - push( pop() - pop() ) { 5 9 3 } • / push( pop() / pop() ) { 5 3 } • * push( pop() * pop() ) { 15 }

18. A.a : 1 ret :A.a(1) B.b : 2 A.a : A.a : ret : .a(5) B.c : 6 ret :A.a(1) B.b : ret :B.b(2) B.c : 3 Handling return addresses class A { void a() { // … B.b() // … B.c() // … } } class B { publicvoid b() { // … c(); // … } publicvoid c() { // … } } 5 1 4 5 2 4 3 6

19. a : a : a : a : 1 1 params :z=5 locals: w b : 2 a : a : a : a : params :z=5 locals: w params :r=6,q=7 locals: s b : c : 6 params :q=8,r=9 locals:s c : 3 Allocating parameters and local variables void a() { int x, y; b(5); c(6, 7); } void b(int z) { int w; c(8, 9); } void c(int q, int r) { int s; } 5 1 5 4 2 4 3 6

20. a : 1 1 a : b : params :z=5 return : a(1) locals: w comp:w=1+5*c(8,9) 2 a : b : params :z=5 return : a(1) locals: w comp:w=1+5*c(8,9) params :q=8,r=9 return : b(2) locals: s comp:7+q 3 The Method Frame void a() { int x, y; b(5); } void b(int z) { int w; w = 1 + 5 * c(8, 9); } int c(int q, int r) { int s; return 7 + q ; } 1 2 3

21. Array based Stack implementation • We will show an array based implementation • We will ignore overflow – exceeding the array size • Can be corrected using resize() • We will ignore underflow – popping from an empty stack • This is the caller’s error – should be an exception • All methods run in O(1) time • Later we will show another implementation

22. Stack public class Stack { private int[] elements; privateint top; private final static int DEFAULT_MAX_SIZE = 10; public Stack(int maxSize){ elements = new int[maxSize];top=0;} public Stack() { this(DEFAULT_MAX_SIZE); } public void push(int x) { elements[top++] =x; } public int pop() { return elements[--top]; } public boolean isEmpty() { return top == 0; } }

23. Lecture G - Collections Unit G3 – Linked List structure

24. Linked Data Structures How to build and use recursive data structures

25. Recursive data structures • An object may have fields of its own type • This does not create a problem since the field only has a reference to the other object • This allows building complicated linked data structures • For each person, a set of friends • For each house on a street, its two neighbors • For each vertex in a binary tree, its two sons • For each web page, the pages that it links to • There are several common structures • Lists (singly linked, doubly linked) • Trees (binary, n-ary, search, …) • Graphs (directed, undirected)

26. Person public class Person { private Person bestFriend; private String name; public Person(String name) { this.name = name; } public String getName() { return name; } public Person getBestFriend() { return bestFriend; } publicvoid setBestFriend(Person friend) { bestFriend = friend; } }

27. Carol Danny d c Bob Alice b a e Person Usage Example (add animation) Person a = new person(“Alice”); Person b = new Person(“Bob”); Person c = new Person(“Carol”); Person d = new Person(“Danny”); a.setBestFriend(b); b.setBestFriend(a); c.setBestFriend(d); d.setbestFriend(a); Person e = c.getBestFriend().getBestFriend(); // a. System.out.println(e.getName()); // Alice if (e == b.getBestFriend()) { … } // true

28. Linked Lists • The simplest linked data structure: a simple linear list. data data data data start null

29. List public class List { private int data; private List next; public List(int data, List next) { this.data = data; this.next = next; } publicint getData() { return data; } public List getNext() { return next; } }

30. Implementing a Set public class Set { private List elements; public Set() { elements = null; } public boolean contains(int x) { for (List c = elements ; c != null ; c = c.getNext()) if (c.getData() == x) returntrue; return false; } public void insert(int x) { if (!contains(x)) elements = new List(x, elements); } }

31. null 3 elements null elements 1 2 5 3 null elements 3 Sample run Set s = new Set(); s.insert(3); s.insert(5) if (s.contains(3)) { … } 1 2 3

32. c 5 3 null elements 4 Sample run Set s = new Set(); s.insert(3); s.insert(5) if (s.contains(3)) { … } 1 2 3 4 if(c.getData()==3)

33. 5 3 null elements 4 Sample run Set s = new Set(); s.insert(3); s.insert(5) if (s.contains(3)) { … } 1 2 3 4 if(c.getData()==3) c

34. List iterator public class ListIterator { private List current; public ListIterator(List list) { current = list; } public boolean hasNext() { return current != null; } public int nextItem() { int item = current.getData(); current = current.getNext(); return item; } }

35. Using Iterators public class Set { private List elements; // constructor and insert() as before publicboolean contains(int x) { for (ListIterator l = new ListIterator(elements);l.hasNext();) if (l.nextItem() == x) return true; return false; } public String toString() { StringBuffer answer = new Stringbuffer(“{“); for (ListIterator l = new ListIterator(elements);l.hasNext();) answer.append(“ “ + l.nextItem() + “ “); answer.append(“}”); return answer.toString(); } }

36. Implementing a Stack public class Stack { private List elements; public Stack() { elements = null; } public void push(int x) { elements = new List(x, elements); } public boolean isEmpty() { return elements == null; } public int pop() { int x = elements.getData(); elements = elements.getNext(); return x; } }

37. Lecture G4 - Collections Unit G4 - List Represnetation of Naturals

38. Recursion on lists An example of using lists and recursion for implementing the natural numbers

39. Foundations of Logic and Computation • What are the very basic axioms of mathematics? • Usually the axioms of Zermello-Frenkel set theory • Only sets exists in this theory • How are natural numbers handled? • Built recursively from sets: 0 = {} , 1 = { {} } , 2 = { {} { {} } } , … • What is the simplest computer? • Usually one takes the “Turing Machine” • What can it do? • Everything that any other computer can do • How? • It can simulate any other computer

40. Successor representation of the naturals • Mathematically, the only basic notions you need in order to define the natural numbers are • 1 (the first natural) • Successor (succ(x) = x + 1) • Induction • We will provide a Java representation of the naturals using the successor notion in a linked list • Mathematical Operations will be defined using recursion 3: null

41. Natural public class Natural { private Natural predecessor; publicstaticfinal Natural ZERO = null; public Natural(Natural predecessor) { this.predecessor = predecessor; } public Natural minus1() { return predecessor; } public Natural plus1() { return new Natural(this); } publicboolean equals1() { return predecessor == ZERO; }

42. + , - , =, > public Natural plus(Natural y) { if (y == ZERO) return this; return this.plus1().plus(y.minus1()); } /** returns max(this-y, 0) */ public Natural minus(Natural y) { if (y == ZERO) returnthis; if (y.equals1()) return ZERO; returnthis.minus1().minus(y.minus1()); } public boolean ge(Natural y) { return y.minus(this) == ZERO; } public boolean eq(Natural y) {returnthis.ge(y) && y.ge(this);} public boolean gt(Natural y) { return !y.ge(this); }

43. *, / , mod public Natural times(Natural y) { if (y == ZERO) return ZERO; returnthis.plus(this.times(y.minus1())); } public Natural div(Natural y) { if ( y.gt(this) ) return ZERO; return ((this.minus(y)).div(y)).plus1(); } public Natural mod(Natural y) { return this.minus((this.div(y)).times(y)); }

44. printing finalstatic Natural ONE = new Natural(ZERO); finalstatic Natural TEN= ONE.plus1().plus1().plus1().plus1(). plus1().plus1() .plus1().plus1().plus1(); privatechar lastDigit() { Natrual digit = this.mod(TEN); if ( digit == ZERO ) return ‘0’; if ( (digit = digit.minus1()) == ZERO ) return ‘1’; if ( (digit = digit.minus1()) == ZERO ) return ‘2’; // … if ( (digit = digit.minus1()) == ZERO ) return ‘8’; return‘9’; } public String toString() { return (TEN.gt(this) ? “” : this.div(TEN).toString()) +lastDigit(); }}

45. Lecture G - Collections