CSE 326: Data StructuresLecture #7
Branching Out
Steve Wolfman
Winter Quarter 2000
Today’s Outline
• Talking about HW #2• Some Tree Review• Binary Trees• Dictionary ADT• Binary Search Trees
HW #2
• Solutions are online – www.cs.washington.edu/326
– navigate to assignments
• Good work!• If you got 5/8 or less, come talk to us• If you don’t understand anything on the quiz, come
talk to us or e-mail us (owner-cse326@cs)– understand the solution even if you got it right on the quiz!
• Problems #3 and #8
Problem #8: How is a Queue like a Stack like a
Priority Queue?• Similar
– store collections of elements
– all elements of the same type
– support an inserting operator and a removing operator
– define a structured ordering on the removal of elements (I.e., not random)
• Different– a priority queue is not a
queue!– very different orderings on
elements– pqueues require comparisons
on the elements– stacks and queues are highly
efficient (pqueues slightly less so)
– theoretical computational power (pqueues and queues beat stacks
Tree Calculations
• Find the longest undirected path in a tree
• Might be:– the longest path in one
of the subtrees
– the longest path that goes through t
t
Tree Calculations ExampleA
E
B
D F
C
G
IH
KJ L
M
L
N
Binary Trees
• Binary tree is– a root
– left subtree (maybe empty)
– right subtree (maybe empty)
• Properties– max # of leaves:
– max # of nodes:
– average depth for N nodes:
• Representation:
A
B
D E
C
F
HG
JIData
right pointer
leftpointer
RepresentationA
right pointer
leftpointer
A
B
D E
C
F
Bright
pointerleft
pointer
Cright
pointerleft
pointer
Dright
pointerleft
pointer
Eright
pointerleft
pointer
Fright
pointerleft
pointer
What We Can Do So Far
• Stack– Push
– Pop
• Queue– Enqueue
– Dequeue
What’s wrong with Lists?
Remember decreaseKey?
• List– Insert
– Remove
– Find
• Priority Queue– Insert
– DeleteMin
Dictionary ADT• Dictionary operations
– create– destroy– insert– find– delete
• Stores values associated with user-specified keys– values may be any (homogenous) type– keys may be any (homogenous) comparable type
• Zasha– interesting ID, but not
enough ooomph!
• Bone– More oomph, less high
scoring Scrabble action
• Wolf– the perfect mix of oomph
and Scrabble value
insert
find(Wolf)
• Darth - formidable
• Wolf - the perfect mix of oomph
and Scrabble value
Search ADT• Dictionary operations
– create– destroy– insert– find– delete
• Stores keys – keys may be any (homogenous) comparable– quickly tests for membership
• Berner
• Whippet
• Alsatian
• Sarplaninac
• Beardie
• Sarloos
• Malamute
• Poodle
insert
find(Wolf)
• Min Pin
NOT FOUND
A Modest Few Uses
• Arrays• Sets• Dictionaries• Router tables• Page tables• Symbol tables• C++ Structures
Desiderata
• Fast insertion– runtime:
• Fast searching– runtime:
• Fast deletion– runtime:
Naïve Implementations
• Linked list
• Unsorted array
• Sorted array
insert deletefind
so close!
Binary Search Tree Dictionary Data Structure
4
121062
115
8
14
13
7 9
• Binary tree property– each node has 2 children
– result:• storage is small• operations are simple• average depth is small
• Search tree property– all keys in left subtree smaller
than root’s key
– all keys in right subtree larger than root’s key
– result:• easy to find any given key
Example and Counter-Example
3
1171
84
15
4
181062
115
8
20
21BINARY SEARCH TREE NOT ABINARY SEARCH TREE
7
15
In Order Listing
2092
155
10
307 17
In order listing:25791015172030
Finding a Node
Node *& find(Comparable key,
Node *& root) {
if (root == NULL)
return root;
else if (key < root->key)
return find(key,
root->left);
else if (key > root->key)
return find(key,
root->right);
else
return root;
}
2092
155
10
307 17
runtime:
Iterative Find
Node * find(Comparable key,
Node * root) {
while (root != NULL &&
root->key != key) {
if (key < root->key)
root = root->left;
else
root = root->right;
}
return root;
} Look familiar?
2092
155
10
307 17
Insert
2092
155
10
307 17
runtime:
void insert(Comparable key,
Node * root) {
Node *& target(find(key,
root));
assert(target == NULL);
target = new Node(key);
}
Digression: Value vs. Reference Parameters
• Value parameters (Object foo)– copies parameter– no side effects
• Reference parameters (Object & foo)– shares parameter– can affect actual value– use when the value needs to be changed
• Const reference parameters (const Object & foo)– shares parameter– cannot affect actual value– use when the value is too intricate for pass-by-value
BuildTree for BSTs
• Suppose the data 1, 2, 3, 4, 5, 6, 7, 8, 9 is inserted into an initially empty BST:– in order
– in reverse order
– median first, then left median, right median, etc.
Analysis of BuildTree
• Worst case: O(n2) as we’ve seen• Average case assuming all orderings equally likely:
Bonus: FindMin/FindMax
• Find minimum
• Find maximum 2092
155
10
307 17