61A Lecture 23
Friday, October 21
Friday, October 21, 2011
Sets
2
Friday, October 21, 2011
Sets
One more built-in Python container type
2
Friday, October 21, 2011
Sets
One more built-in Python container type
• Set literals are enclosed in braces
2
Friday, October 21, 2011
Sets
One more built-in Python container type
• Set literals are enclosed in braces
• Duplicate elements are removed on construction
2
Friday, October 21, 2011
Sets
One more built-in Python container type
• Set literals are enclosed in braces
• Duplicate elements are removed on construction
• Sets are unordered, just like dictionary entries
2
Friday, October 21, 2011
Sets
One more built-in Python container type
• Set literals are enclosed in braces
• Duplicate elements are removed on construction
• Sets are unordered, just like dictionary entries
>>> s = {3, 2, 1, 4, 4}
>>> s
{1, 2, 3, 4}
2
Friday, October 21, 2011
Sets
One more built-in Python container type
• Set literals are enclosed in braces
• Duplicate elements are removed on construction
• Sets are unordered, just like dictionary entries
>>> s = {3, 2, 1, 4, 4}
>>> s
{1, 2, 3, 4}
>>> 3 in s
True
2
Friday, October 21, 2011
Sets
One more built-in Python container type
• Set literals are enclosed in braces
• Duplicate elements are removed on construction
• Sets are unordered, just like dictionary entries
>>> s = {3, 2, 1, 4, 4}
>>> s
{1, 2, 3, 4}
>>> 3 in s
True
>>> len(s)
4
2
Friday, October 21, 2011
Sets
One more built-in Python container type
• Set literals are enclosed in braces
• Duplicate elements are removed on construction
• Sets are unordered, just like dictionary entries
>>> s = {3, 2, 1, 4, 4}
>>> s
{1, 2, 3, 4}
>>> 3 in s
True
>>> len(s)
4
>>> s.union({1, 5})
{1, 2, 3, 4, 5}
2
Friday, October 21, 2011
Sets
One more built-in Python container type
• Set literals are enclosed in braces
• Duplicate elements are removed on construction
• Sets are unordered, just like dictionary entries
>>> s = {3, 2, 1, 4, 4}
>>> s
{1, 2, 3, 4}
>>> 3 in s
True
>>> len(s)
4
>>> s.union({1, 5})
{1, 2, 3, 4, 5}
>>> s.intersection({6, 5, 4, 3})
{3, 4}
2
Friday, October 21, 2011
Implementing Sets
3
Friday, October 21, 2011
Implementing Sets
The interface for sets
3
Friday, October 21, 2011
Implementing Sets
The interface for sets
• Membership testing: Is a value an element of a set?
3
Friday, October 21, 2011
Implementing Sets
The interface for sets
• Membership testing: Is a value an element of a set?
• Union: Return a set with all elements in set1 or set2
3
Friday, October 21, 2011
Implementing Sets
The interface for sets
• Membership testing: Is a value an element of a set?
• Union: Return a set with all elements in set1 or set2
Union
1
4
2
3
5
1
4 5
3
2
3
3
Friday, October 21, 2011
Implementing Sets
The interface for sets
• Membership testing: Is a value an element of a set?
• Union: Return a set with all elements in set1 or set2
• Intersection: Return a set with any elements in set1 and set2
Union
1
4
2
3
5
1
4 5
3
2
3
3
Friday, October 21, 2011
Implementing Sets
The interface for sets
• Membership testing: Is a value an element of a set?
• Union: Return a set with all elements in set1 or set2
• Intersection: Return a set with any elements in set1 and set2
Union
Intersection
1
4
2
3
5
1
4 5
3
1
4
2
3
5
3
2
3
3
3
Friday, October 21, 2011
Implementing Sets
The interface for sets
• Membership testing: Is a value an element of a set?
• Union: Return a set with all elements in set1 or set2
• Intersection: Return a set with any elements in set1 and set2
• Adjunction: Return a set with all elements in s and a value v
Union
Intersection
1
4
2
3
5
1
4 5
3
1
4
2
3
5
3
2
3
3
3
Friday, October 21, 2011
Implementing Sets
The interface for sets
• Membership testing: Is a value an element of a set?
• Union: Return a set with all elements in set1 or set2
• Intersection: Return a set with any elements in set1 and set2
• Adjunction: Return a set with all elements in s and a value v
Union
Intersection
1
4
2
3
5
1
4 5
3
Adjunction
1
4
2
3
5
3
1
4
3
2
3
2
1 2
3
4
3
3
Friday, October 21, 2011
Sets as Unordered Sequences
Proposal 1: A set is represented by a recursive list that
contains no duplicate items
4
Friday, October 21, 2011
Sets as Unordered Sequences
Proposal 1: A set is represented by a recursive list that
contains no duplicate items
def empty(s):
return s is Rlist.empty
4
Friday, October 21, 2011
Sets as Unordered Sequences
Proposal 1: A set is represented by a recursive list that
contains no duplicate items
def empty(s):
return s is Rlist.empty
def set_contains(s, v):
4
Friday, October 21, 2011
Sets as Unordered Sequences
Proposal 1: A set is represented by a recursive list that
contains no duplicate items
def empty(s):
return s is Rlist.empty
def set_contains(s, v):
if empty(s):
return False
4
Friday, October 21, 2011
Sets as Unordered Sequences
Proposal 1: A set is represented by a recursive list that
contains no duplicate items
def empty(s):
return s is Rlist.empty
def set_contains(s, v):
if empty(s):
return False
elif s.first == v:
return True
4
Friday, October 21, 2011
Sets as Unordered Sequences
Proposal 1: A set is represented by a recursive list that
contains no duplicate items
def empty(s):
return s is Rlist.empty
def set_contains(s, v):
if empty(s):
return False
elif s.first == v:
return True
return set_contains(s.rest, v)
4
Friday, October 21, 2011
Sets as Unordered Sequences
Proposal 1: A set is represented by a recursive list that
contains no duplicate items
def empty(s):
return s is Rlist.empty
def set_contains(s, v):
if empty(s):
return False
elif s.first == v:
return True
return set_contains(s.rest, v)
Demo
4
Friday, October 21, 2011
Review: Order of Growth
5
Friday, October 21, 2011
Review: Order of Growth
For a set operation that takes "linear" time, we say that
5
Friday, October 21, 2011
Review: Order of Growth
For a set operation that takes "linear" time, we say that
n: size of the set
5
Friday, October 21, 2011
Review: Order of Growth
For a set operation that takes "linear" time, we say that
n: size of the set
R(n): number of steps required to perform the operation
5
Friday, October 21, 2011
Review: Order of Growth
For a set operation that takes "linear" time, we say that
n: size of the set
R(n): number of steps required to perform the operation
R(n) = Θ(n)
5
Friday, October 21, 2011
Review: Order of Growth
For a set operation that takes "linear" time, we say that
n: size of the set
R(n): number of steps required to perform the operation
R(n) = Θ(n)
which means that there are constants k1 and k2 such that
5
Friday, October 21, 2011
Review: Order of Growth
For a set operation that takes "linear" time, we say that
n: size of the set
R(n): number of steps required to perform the operation
R(n) = Θ(n)
which means that there are constants k1 and k2 such that
k1 · n ≤ R(n) ≤ k2 · n
5
Friday, October 21, 2011
Review: Order of Growth
For a set operation that takes "linear" time, we say that
n: size of the set
R(n): number of steps required to perform the operation
R(n) = Θ(n)
which means that there are constants k1 and k2 such that
k1 · n ≤ R(n) ≤ k2 · n
for sufficiently large values of n.
5
Friday, October 21, 2011
Review: Order of Growth
For a set operation that takes "linear" time, we say that
n: size of the set
R(n): number of steps required to perform the operation
R(n) = Θ(n)
which means that there are constants k1 and k2 such that
k1 · n ≤ R(n) ≤ k2 · n
for sufficiently large values of n.
Demo
5
Friday, October 21, 2011
Sets as Unordered Sequences
6
Friday, October 21, 2011
Sets as Unordered Sequences
def adjoin_set(s, v):
6
Friday, October 21, 2011
Sets as Unordered Sequences
def adjoin_set(s, v):
if set_contains(s, v):
6
Friday, October 21, 2011
Sets as Unordered Sequences
def adjoin_set(s, v):
if set_contains(s, v):
return s
6
Friday, October 21, 2011
Sets as Unordered Sequences
def adjoin_set(s, v):
if set_contains(s, v):
return s
return Rlist(v, s)
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
if set_contains(s, v):
return s
return Rlist(v, s)
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
Θ(n)
if set_contains(s, v):
return s
return Rlist(v, s)
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
if set_contains(s, v):
return s
Θ(n)
The size of
the set
return Rlist(v, s)
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
if set_contains(s, v):
return s
Θ(n)
The size of
the set
return Rlist(v, s)
def intersect_set(set1, set2):
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
if set_contains(s, v):
return s
Θ(n)
The size of
the set
return Rlist(v, s)
def intersect_set(set1, set2):
f = lambda v: set_contains(set2, v)
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
if set_contains(s, v):
return s
Θ(n)
The size of
the set
return Rlist(v, s)
def intersect_set(set1, set2):
f = lambda v: set_contains(set2, v)
return filter_rlist(set1, f)
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
if set_contains(s, v):
return s
Θ(n)
The size of
the set
return Rlist(v, s)
def intersect_set(set1, set2):
Θ(n2 )
f = lambda v: set_contains(set2, v)
return filter_rlist(set1, f)
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
if set_contains(s, v):
return s
Θ(n)
The size of
the set
return Rlist(v, s)
def intersect_set(set1, set2):
f = lambda v: set_contains(set2, v)
return filter_rlist(set1, f)
Θ(n2 )
The size of
the larger set
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
if set_contains(s, v):
return s
Θ(n)
The size of
the set
return Rlist(v, s)
def intersect_set(set1, set2):
f = lambda v: set_contains(set2, v)
return filter_rlist(set1, f)
Θ(n2 )
The size of
the larger set
def union_set(set1, set2):
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
if set_contains(s, v):
return s
Θ(n)
The size of
the set
return Rlist(v, s)
def intersect_set(set1, set2):
f = lambda v: set_contains(set2, v)
return filter_rlist(set1, f)
Θ(n2 )
The size of
the larger set
def union_set(set1, set2):
f = lambda v: not set_contains(set2, v)
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
def adjoin_set(s, v):
if set_contains(s, v):
return s
Θ(n)
The size of
the set
return Rlist(v, s)
def intersect_set(set1, set2):
f = lambda v: set_contains(set2, v)
return filter_rlist(set1, f)
Θ(n2 )
The size of
the larger set
def union_set(set1, set2):
f = lambda v: not set_contains(set2, v)
set1_not_set2 = filter_rlist(set1, f)
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
Θ(n)
def adjoin_set(s, v):
if set_contains(s, v):
return s
The size of
the set
return Rlist(v, s)
Θ(n2 )
def intersect_set(set1, set2):
f = lambda v: set_contains(set2, v)
return filter_rlist(set1, f)
The size of
the larger set
def union_set(set1, set2):
f = lambda v: not set_contains(set2, v)
set1_not_set2 = filter_rlist(set1, f)
return extend_rlist(set1_not_set2, set2)
6
Friday, October 21, 2011
Sets as Unordered Sequences
Time order of growth
Θ(n)
def adjoin_set(s, v):
if set_contains(s, v):
return s
The size of
the set
return Rlist(v, s)
Θ(n2 )
def intersect_set(set1, set2):
f = lambda v: set_contains(set2, v)
return filter_rlist(set1, f)
The size of
the larger set
def union_set(set1, set2):
Θ(n2 )
f = lambda v: not set_contains(set2, v)
set1_not_set2 = filter_rlist(set1, f)
return extend_rlist(set1_not_set2, set2)
6
Friday, October 21, 2011
Sets as Ordered Sequences
Proposal 2: A set is represented by a recursive list with
unique elements ordered from least to greatest
7
Friday, October 21, 2011
Sets as Ordered Sequences
Proposal 2: A set is represented by a recursive list with
unique elements ordered from least to greatest
def set_contains2(s, v):
7
Friday, October 21, 2011
Sets as Ordered Sequences
Proposal 2: A set is represented by a recursive list with
unique elements ordered from least to greatest
def set_contains2(s, v):
if empty(s) or s.first > v:
return False
7
Friday, October 21, 2011
Sets as Ordered Sequences
Proposal 2: A set is represented by a recursive list with
unique elements ordered from least to greatest
def set_contains2(s, v):
if empty(s) or s.first > v:
return False
elif s.first == v:
return True
7
Friday, October 21, 2011
Sets as Ordered Sequences
Proposal 2: A set is represented by a recursive list with
unique elements ordered from least to greatest
def set_contains2(s, v):
if empty(s) or s.first > v:
return False
elif s.first == v:
return True
return set_contains2(s.rest, v)
7
Friday, October 21, 2011
Sets as Ordered Sequences
Proposal 2: A set is represented by a recursive list with
unique elements ordered from least to greatest
def set_contains2(s, v):
if empty(s) or s.first > v:
return False
elif s.first == v:
return True
return set_contains2(s.rest, v)
Order of growth?
7
Friday, October 21, 2011
Sets as Ordered Sequences
Proposal 2: A set is represented by a recursive list with
unique elements ordered from least to greatest
def set_contains2(s, v):
if empty(s) or s.first > v:
return False
elif s.first == v:
return True
return set_contains2(s.rest, v)
Order of growth?
Θ(n)
7
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
if e1 == e2:
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
if e1 == e2:
rest = intersect_set2(set1.rest, set2.rest)
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
if e1 == e2:
rest = intersect_set2(set1.rest, set2.rest)
return Rlist(e1, rest)
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
if e1 == e2:
rest = intersect_set2(set1.rest, set2.rest)
return Rlist(e1, rest)
elif e1 < e2:
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
if e1 == e2:
rest = intersect_set2(set1.rest, set2.rest)
return Rlist(e1, rest)
elif e1 < e2:
return intersect_set2(set1.rest, set2)
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
if e1 == e2:
rest = intersect_set2(set1.rest, set2.rest)
return Rlist(e1, rest)
elif e1 < e2:
return intersect_set2(set1.rest, set2)
elif e2 < e1:
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
if e1 == e2:
rest = intersect_set2(set1.rest, set2.rest)
return Rlist(e1, rest)
elif e1 < e2:
return intersect_set2(set1.rest, set2)
elif e2 < e1:
return intersect_set2(set1, set2.rest)
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
if e1 == e2:
rest = intersect_set2(set1.rest, set2.rest)
return Rlist(e1, rest)
elif e1 < e2:
return intersect_set2(set1.rest, set2)
elif e2 < e1:
return intersect_set2(set1, set2.rest)
Demo
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
if e1 == e2:
rest = intersect_set2(set1.rest, set2.rest)
return Rlist(e1, rest)
elif e1 < e2:
return intersect_set2(set1.rest, set2)
elif e2 < e1:
return intersect_set2(set1, set2.rest)
Demo
Order of growth?
8
Friday, October 21, 2011
Set Intersection Using Ordered Sequences
This algorithm assumes that elements are in order.
def intersect_set2(set1, set2):
if empty(set1) or empty(set2):
return Rlist.empty
e1, e2 = set1.first, set2.first
if e1 == e2:
rest = intersect_set2(set1.rest, set2.rest)
return Rlist(e1, rest)
elif e1 < e2:
return intersect_set2(set1.rest, set2)
elif e2 < e1:
return intersect_set2(set1, set2.rest)
Demo
Order of growth?
Θ(n)
8
Friday, October 21, 2011
Tree Sets
9
Friday, October 21, 2011
Tree Sets
Proposal 3: A set is represented as a Tree. Each entry is:
9
Friday, October 21, 2011
Tree Sets
Proposal 3: A set is represented as a Tree. Each entry is:
• Larger than all entries in its left branch and
9
Friday, October 21, 2011
Tree Sets
Proposal 3: A set is represented as a Tree. Each entry is:
• Larger than all entries in its left branch and
• Smaller than all entries in its right branch
9
Friday, October 21, 2011
Tree Sets
Proposal 3: A set is represented as a Tree. Each entry is:
• Larger than all entries in its left branch and
• Smaller than all entries in its right branch
7
3
1
9
5
11
9
Friday, October 21, 2011
Tree Sets
Proposal 3: A set is represented as a Tree. Each entry is:
• Larger than all entries in its left branch and
• Smaller than all entries in its right branch
7
3
1
3
9
5
1
11
7
5
9
11
9
Friday, October 21, 2011
Tree Sets
Proposal 3: A set is represented as a Tree. Each entry is:
• Larger than all entries in its left branch and
• Smaller than all entries in its right branch
7
3
1
3
9
5
1
11
5
3
7
5
9
1
9
7
11
11
9
Friday, October 21, 2011
Membership in Tree Sets
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
• The element is either in the left or right sub-branch
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
• The element is either in the left or right sub-branch
• By focusing on one branch, we reduce the set by about half
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
• The element is either in the left or right sub-branch
• By focusing on one branch, we reduce the set by about half
def set_contains3(s, v):
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
• The element is either in the left or right sub-branch
• By focusing on one branch, we reduce the set by about half
def set_contains3(s, v):
if s is None:
return False
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
• The element is either in the left or right sub-branch
• By focusing on one branch, we reduce the set by about half
def set_contains3(s, v):
if s is None:
return False
elif s.entry == v:
return True
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
• The element is either in the left or right sub-branch
• By focusing on one branch, we reduce the set by about half
def set_contains3(s, v):
if s is None:
return False
elif s.entry == v:
return True
elif s.entry < v:
return set_contains3(s.right, v)
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
• The element is either in the left or right sub-branch
• By focusing on one branch, we reduce the set by about half
def set_contains3(s, v):
if s is None:
return False
elif s.entry == v:
return True
elif s.entry < v:
return set_contains3(s.right, v)
elif s.entry > v:
return set_contains3(s.left, v)
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
• The element is either in the left or right sub-branch
• By focusing on one branch, we reduce the set by about half
def set_contains3(s, v):
5
if s is None:
return False
3
elif s.entry == v:
9
return True
elif s.entry < v:
1
7
11
return set_contains3(s.right, v)
elif s.entry > v:
return set_contains3(s.left, v)
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
• The element is either in the left or right sub-branch
• By focusing on one branch, we reduce the set by about half
9
def set_contains3(s, v):
5
if s is None:
return False
3
elif s.entry == v:
9
return True
elif s.entry < v:
1
7
11
return set_contains3(s.right, v)
elif s.entry > v:
return set_contains3(s.left, v)
10
Friday, October 21, 2011
Membership in Tree Sets
Set membership tests traverse the tree
• The element is either in the left or right sub-branch
• By focusing on one branch, we reduce the set by about half
9
def set_contains3(s, v):
5
if s is None:
return False
3
elif s.entry == v:
9
return True
elif s.entry < v:
1
7
11
return set_contains3(s.right, v)
elif s.entry > v:
return set_contains3(s.left, v)
If 9 is in the
set, it is in
this branch
10
Friday, October 21, 2011
Adjoining to a Tree Set
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
5
3
1
9
7
11
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
5
3
9
1
7
11
Right!
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
5
3
9
1
7
11
Right!
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
5
9
3
9
7
1
7
11
11
Right!
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
5
9
3
9
7
1
7
Right!
11
11
Left!
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
5
9
7
3
9
7
1
7
Right!
11
11
Left!
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
5
9
7
3
9
7
1
7
Right!
11
None None
11
Left!
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
5
9
7
3
9
7
1
7
Right!
11
None None
11
Left!
Right!
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
8
5
9
7
None
3
9
7
1
7
Right!
11
None None
11
Left!
Right!
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
8
5
9
7
None
3
9
7
1
7
Right!
11
None None
11
Left!
Right!
Stop!
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
8
5
9
7
None
3
9
7
1
7
Right!
11
None None
11
Left!
Right!
Stop!
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
8
5
9
7
None
3
9
7
1
7
Right!
11
None None
11
Left!
Right!
Stop!
8
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
8
5
9
7
None
3
9
7
1
7
Right!
11
None None
11
Left!
Right!
Stop!
7
8
8
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
8
5
9
7
None
3
9
7
1
7
Right!
11
None None
11
Left!
Right!
Stop!
9
7
8
8
7
11
8
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
8
5
9
7
None
3
9
7
1
7
11
None None
11
Right!
Left!
Right!
Stop!
5
9
7
8
3
1
8
9
7
7
11
11
8
8
11
Friday, October 21, 2011
Adjoining to a Tree Set
8
8
8
8
5
9
7
None
3
9
7
1
7
11
None None
11
Right!
Left!
Right!
Stop!
5
9
7
8
3
1
8
9
7
7
11
8
11
8
Demo
11
Friday, October 21, 2011
What Did I Leave Out?
12
Friday, October 21, 2011
What Did I Leave Out?
Sets as ordered sequences:
12
Friday, October 21, 2011
What Did I Leave Out?
Sets as ordered sequences:
• Adjoining an element to a set
12
Friday, October 21, 2011
What Did I Leave Out?
Sets as ordered sequences:
• Adjoining an element to a set
• Union of two sets
12
Friday, October 21, 2011
What Did I Leave Out?
Sets as ordered sequences:
• Adjoining an element to a set
• Union of two sets
Sets as binary trees:
12
Friday, October 21, 2011
What Did I Leave Out?
Sets as ordered sequences:
• Adjoining an element to a set
• Union of two sets
Sets as binary trees:
• Intersection of two sets
12
Friday, October 21, 2011
What Did I Leave Out?
Sets as ordered sequences:
• Adjoining an element to a set
• Union of two sets
Sets as binary trees:
• Intersection of two sets
• Union of two sets
12
Friday, October 21, 2011
What Did I Leave Out?
Sets as ordered sequences:
• Adjoining an element to a set
• Union of two sets
Sets as binary trees:
• Intersection of two sets
• Union of two sets
That's homework 8!
12
Friday, October 21, 2011
What Did I Leave Out?
Sets as ordered sequences:
• Adjoining an element to a set
• Union of two sets
Sets as binary trees:
• Intersection of two sets
• Union of two sets
That's homework 8!
No lecture on Monday
12
Friday, October 21, 2011
What Did I Leave Out?
Sets as ordered sequences:
• Adjoining an element to a set
• Union of two sets
Sets as binary trees:
• Intersection of two sets
• Union of two sets
That's homework 8!
No lecture on Monday
Midterm 2 on Monday, 7pm-9pm
12
Friday, October 21, 2011
What Did I Leave Out?
Sets as ordered sequences:
• Adjoining an element to a set
• Union of two sets
Sets as binary trees:
• Intersection of two sets
• Union of two sets
That's homework 8!
No lecture on Monday
Midterm 2 on Monday, 7pm-9pm
Good luck!
12
Friday, October 21, 2011