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

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


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


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


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 = new int[maxSize]; size=0; } public Set() { this(DEFAULT_LENGTH);}


Set methods

public boolean contains (int x) { for(int j=0 ; j<size ; j++) if ( elements[j] == x) return true; return false; } public void insert(int x) { if ( !contains(x) ) elements[size++] = x; } public void delete(int x){ for(int j=0 ; j<size ; j++) if ( elements[j] == x) { elements[j] = elements[--size]; return; } }


Set – resizing on overflow

public void safeInsert(int x) { if ( !contains(x) ) { if (size == elements.length) resize(); elements[size++] = x; } }

private void resize() { int[] temp = new int[2*elements.length]; for (int j=0 ; j<size ; j++) temp[j] = elements[j]; elements = temp; }


Set – variants for union methods

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


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


ImmutableSet

public class ImmutableSet { /** The elements of this set, ordered from lowest to * highest */ private int[] 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 = new int[elements.length]; for(int j=0 ; j < elements.length;j++) this.elements[j]=elements[j]; MergeSort.mergeSort(this.elements); }


ImmutableSet – binary search

public boolean contains (int x) { return contains(x, 0, elements.length - 1); } private boolean contains(int x, int low,

int high){ if (low > high) return false; 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); }



Unit G2 - Stacks


Stacks

How to use and implement stacks


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


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 }


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 }


Handling return addresses

class A {

void a() {

// …

B.b()

// …

B.c()

// …

}

}

class B {

public void b() {

// …

c();

// …

}

public void c() {

// …

}

}

1

4

5A.a :

B.b : 2ret :A.a(1)

A.a :

B.b :

3B.c :

ret :A.a(1)

ret :B.b(2)

A.a :

B.c : 6ret : .a(5)

1

2

3

4

5

6


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;

}

a : 1a : 1a :a :

2params :z=5

locals: wb :

a :a :

3

params :z=5

locals: wb :

params :q=8,r=9

locals:sc :

4

5

a :a :

6params :r=6,q=7

locals: sc :

1

2

3

4

5

6


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 ;

}

1a : 1

a :

b : 2params :z=5

return : a(1)

locals: w

comp:w=1+5*c(8,9)

a :

3

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

1

2

3


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


Stack

public class Stack { private int[] elements; private int 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; }}



Unit G3 – Linked List structure


Linked Data Structures

How to build and use recursive data

structures


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)


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; } public void setBestFriend(Person friend) { bestFriend = friend; }}


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()); // Aliceif (e == b.getBestFriend()) { … } // true

e

CarolCarol

c

DannyDannyd

BobBobb

AliceAlicea


Linked Lists

• The simplest linked data structure: a simple linear list.

datadata

data

data

null

start


List

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


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) return true; return false; } public void insert(int x) { if (!contains(x)) elements = new List(x, elements); } }


Sample run

Set s = new Set();s.insert(3);s.insert(5)if (s.contains(3)) { … }

1

2

3

nullelements

1

nullelements 3

2

nullelements 35

3


Sample run

Set s = new Set();s.insert(3);s.insert(5)if (s.contains(3)) { … }

1

2

3

4

nullelements 35

4

c

if(c.getData()==3)


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


Using Iterators

public class Set { private List elements; // constructor and insert() as before public boolean 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(); }}


Implementing a Stackpublic 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; }}


Lecture G4 - Collections

Unit G4 - List Represnetation of Naturals


Recursion on lists

An example of using lists and recursion

for implementing the natural numbers


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


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

null

3:


Naturalpublic class Natural { private Natural predecessor; public static final Natural ZERO = null; public Natural(Natural predecessor) { this.predecessor = predecessor; } public Natural minus1() { return predecessor; } public Natural plus1() { return new Natural(this); } public boolean equals1() { return predecessor == ZERO; }


+ , - , =, > 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) return this; if (y.equals1()) return ZERO; return this.minus1().minus(y.minus1()); }

public boolean ge(Natural y) { return y.minus(this) == ZERO; }

public boolean eq(Natural y) {return this.ge(y) && y.ge(this);}

public boolean gt(Natural y) { return !y.ge(this); }


*, / , mod public Natural times(Natural y) { if (y == ZERO) return ZERO; return this.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)); }


printing final static Natural ONE = new Natural(ZERO); final static Natural TEN= ONE.plus1().plus1().plus1().plus1(). plus1().plus1() .plus1().plus1().plus1();

private char 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(); }}

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

Documents

Transcript of Slide 1 of 45. Lecture G - Collections Unit G1 – Abstract Data Types.