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 new intmaxSize
size0 public Set()
this(DEFAULT_LENGTH)
7
Set methods
public boolean contains (int x) for(int
j0 jltsize j) if ( elementsj x)
return true return false
public void insert(int x) if (
!contains(x) ) elementssize x
public void delete(int x) for(int j0
jltsize j) if ( elementsj x)
elementsj elements--size
return
8
Set resizing on overflow
public void safeInsert(int x) if (
!contains(x) ) if (size
elements.length) resize()
elementssize x private void
resize() int temp new
int2elements.length for (int j0 jltsize
j) tempj elementsj elements
temp
9
Set variants for union methods
public void insertSet(Set s) for (int j
0 j lt s.size j) insert(s.elementsj)
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

• 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 intelements.length
  
• for(int j0 j lt elements.lengthj)
• this.elementsjelementsj
• MergeSort.mergeSort(this.elements)

12
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 gt high) return
false int med (low high) / 2 if (x
elementsmed) return true else if
(x lt elementsmed) return contains(x,
low, med-1) else return contains(x,
med1, 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
Handling return addresses
class A void a() // B.b() //
B.c() // class B public
void b() // c() //
public void c() //
5
1
4
5
2
4
3
6
19
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
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 callers 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 private int top private final
static int DEFAULT_MAX_SIZE 10 public
Stack(int maxSize) elements new
intmaxSizetop0 public Stack()
this(DEFAULT_MAX_SIZE) public void
push(int x) elementstop 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 public void
setBestFriend(Person friend) bestFriend
friend
27
Person Usage Example (add animation)
Person a new person(Alice) Person b new
Person(Bob) Person c new Person(Carol) Per
son d new Person(Danny) a.setBestFriend(b)
b.setBestFriend(a) c.setBestFriend(d) d.setbest
Friend(a) Person e c.getBestFriend().getBestFri
end() // 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 public int 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) return true
return false public void insert(int x)
if (!contains(x)) elements new List(x,
elements)
31
Sample run
Set s new Set() s.insert(3) s.insert(5) if
(s.contains(3))
1
2
3
32
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
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 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()
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 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
42
, - , , gt
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)

43
, / , 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))
44
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()
45
Lecture G - Collections