Download CSE 326: Data Structures Lecture #7 Branching Out

CSE 326: Data Structures
Lecture #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 Example
A
B
D
C
E
F
G
H
J
M
K
I
L
L
N
Binary Trees
• Binary tree is
– a root
– left subtree (maybe empty)
– right subtree (maybe empty)
A
B
C
• Properties
– max # of leaves:
– max # of nodes:
– average depth for N nodes:
D
E
F
G
H
• Representation:
Data
left
right
pointer pointer
I
J
Representation
A
A
left right
pointerpointer
B
B
C
left right
pointerpointer
left right
pointerpointer
D
E
F
left right
pointerpointer
left right
pointerpointer
left right
pointerpointer
D
C
E
F
What We Can Do So Far
• Stack
• List
– Push
– Pop
– Insert
– Remove
– Find
• Queue
– Enqueue
– Dequeue
• Priority Queue
– Insert
– DeleteMin
What’s wrong with Lists?
Remember decreaseKey?
Dictionary ADT
•
• Dictionary operations
–
–
–
–
–
create
destroy
insert
find
delete
– interesting ID, but not
enough ooomph!
insert
• Darth
- formidable
Zasha
•
Bone
– More oomph, less high
scoring Scrabble action
•
find(Wolf)
• Wolf
- the perfect mix of oomph
Wolf
– the perfect mix of oomph
and Scrabble value
and Scrabble value
• Stores values associated with user-specified keys
– values may be any (homogenous) type
– keys may be any (homogenous) comparable type
Search ADT
• Dictionary operations
–
–
–
–
–
create
destroy
insert
find
delete
insert
• Min Pin
find(Wolf)
NOT FOUND
• Stores keys
– keys may be any (homogenous) comparable
– quickly tests for membership
•
•
•
•
•
•
•
•
Berner
Whippet
Alsatian
Sarplaninac
Beardie
Sarloos
Malamute
Poodle
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
insert
• Linked list
• Unsorted array
• Sorted array
so close!
find
delete
Binary Search Tree
Dictionary Data Structure
• Binary tree property
8
– 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
5
2
11
6
4
10
7
9
12
14
13
Example and Counter-Example
15
8
4
1
8
7
5
11
3
BINARY SEARCH TREE
2
7
4
11
6
10
15
NOT A
BINARY SEARCH TREE
18
20
21
In Order Listing
10
5
15
2
9
7
20
17 30
In order listing:
25791015172030
Finding a Node
10
5
15
2
9
7
runtime:
20
17 30
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;
}
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;
}
10
5
15
2
9
7
return root;
}
Look familiar?
20
17 30
Insert
void insert(Comparable key,
Node * root) {
Node *& target(find(key,
root));
assert(target == NULL);
10
5
15
2
9
20
target = new Node(key);
}
7
runtime:
17 30
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
10
5
• Find maximum
15
2
9
7
20
17 30