1 / 45

Lecture G - Collections

Lecture G - Collections. Unit G1 – Abstract Data Types. Collections. Array-based implementations of simple collection abstract data types. 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

dougal
Download Presentation

Lecture G - Collections

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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

More Related