CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.
-
Upload
sheryl-taylor -
Category
Documents
-
view
213 -
download
0
Transcript of CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.
![Page 1: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/1.jpg)
CPSC 221: Data StructuresLecture #5
Branching Out
Steve Wolfman
2014W1
1
![Page 2: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/2.jpg)
Today’s Outline
• Binary Trees• Dictionary ADT• Binary Search Trees• Deletion• Some troubling questions
2
![Page 3: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/3.jpg)
Binary Trees
• Binary tree is either– empty (NULL for us), or– a datum, a left subtree, and a
right subtree
• Properties– max # of leaves: – max # of nodes:
• Representation:
A
B
D E
C
F
HG
JIData
right pointer
leftpointer 3
![Page 4: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/4.jpg)
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
struct Node { KTYPE key; DTYPE data; Node * left; Node * right;};
4
![Page 5: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/5.jpg)
Today’s Outline
• Binary Trees• Dictionary ADT• Binary Search Trees• Deletion• Some troubling questions
5
![Page 6: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/6.jpg)
What We Can Do So Far
• Stack– Push– Pop
• Queue– Enqueue– Dequeue
What’s wrong with Lists?
• List– Insert– Remove– Find
• Priority Queue (skipped!)– Insert– DeleteMin
6
![Page 7: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/7.jpg)
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
• midterm– would be tastier with
brownies• prog-project
– so painful… who designed this language?
• wolf– the perfect mix of oomph
and Scrabble value
insert
find(wolf)
• brownies - tasty
• wolf - the perfect mix of oomph
and Scrabble value
7
![Page 8: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/8.jpg)
Search/Set 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
8
![Page 9: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/9.jpg)
A Modest Few Uses
• Arrays and “Associative” Arrays• Sets• Dictionaries• Router tables• Page tables• Symbol tables• C++ Structures
9
![Page 10: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/10.jpg)
Desiderata
• Fast insertion– runtime:
• Fast searching– runtime:
• Fast deletion– runtime:
10
![Page 11: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/11.jpg)
Naïve Implementations
• Linked list
• Unsorted array
• Sorted array
insert deletefind
worst one… yet so close! 11
![Page 12: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/12.jpg)
Today’s Outline
• Binary Trees• Dictionary ADT• Binary Search Trees• Deletion• Some troubling questions
12
![Page 13: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/13.jpg)
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
13*Technically: a result of both properties.
![Page 14: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/14.jpg)
Example and Counter-Example
3
1171
84
5
4
181062
115
8
20
21BINARY SEARCH TREE NOT ABINARY SEARCH TREE
7
15
14
![Page 15: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/15.jpg)
In Order Listing
2092
155
10
307 17
In order listing:25791015172030
struct Node { KTYPE key; DTYPE data; Node * left; Node * right;};
15
![Page 16: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/16.jpg)
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:
a. O(1)b. O(lg n)c. O(n)d. O(n lg n)e. None of these
16
![Page 17: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/17.jpg)
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
WARNING: Much fancy footwork with refs (&) coming. You can do all of this without refs... just watch out for special cases.
17
![Page 18: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/18.jpg)
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
(It’s trickier to get the ref return to work here.)18
![Page 19: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/19.jpg)
Insert
2092
155
10
307 17
runtime:
// Precondition: key is not// already in the tree!void insert(Comparable key, Node * root) { Node *& target(find(key, root)); assert(target == NULL);
target = new Node(key);}
Funky game we can play with the *& version.19
![Page 20: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/20.jpg)
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 (Object const & foo)– shares parameter– cannot affect actual value– use when the value is too big for copying in pass-by-value20
![Page 21: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/21.jpg)
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.so: 5, 3, 8, 2, 4, 7, 9, 1, 6
21
![Page 22: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/22.jpg)
Analysis of BuildTree
• Worst case: O(n2) as we’ve seen• Average case assuming all orderings equally likely
turns out to be O(n lg n).
22
![Page 23: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/23.jpg)
Bonus: FindMin/FindMax
• Find minimum
• Find maximum2092
155
10
307 17
23
![Page 24: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/24.jpg)
Double Bonus: Successor
Find the next larger node
in this node’s subtree.
Node *& succ(Node *& root) { if (root->right == NULL) return root->right; else return min(root->right);}
Node *& min(Node *& root) { if (root->left == NULL) return root; else return min(root->left);}
2092
155
10
307 17
24
![Page 25: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/25.jpg)
More Double Bonus: Predecessor
Find the next smaller node
in this node’s subtree.
Node *& pred(Node *& root) { if (root->left == NULL) return root->left; else return max(root->left);}
Node *& max(Node *& root) { if (root->right == NULL) return root; else return max(root->right);}
2092
155
10
307 17
25
![Page 26: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/26.jpg)
Today’s Outline
• Some Tree Review (here for reference, not discussed)
• Binary Trees• Dictionary ADT• Binary Search Trees• Deletion• Some troubling questions
26
![Page 27: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/27.jpg)
Deletion
2092
155
10
307 17
Why might deletion be harder than insertion?
27
![Page 28: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/28.jpg)
Lazy Deletion
• Instead of physically deleting nodes, just mark them as deleted (with a “tombstone”)+ simpler+ physical deletions done in batches+ some adds just flip deleted flag– small amount of extra memory
for deleted flag– many tombstones slow finds– some operations may have to be
modified (e.g., min and max)
2092
155
10
307 17
28
![Page 29: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/29.jpg)
Lazy Deletion
2092
155
10
307 17
Delete(17)
Delete(15)
Delete(5)
Find(9)
Find(16)
Insert(5)
Find(17)29
![Page 30: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/30.jpg)
Deletion - Leaf Case
2092
155
10
307 17
Delete(17)
30
![Page 31: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/31.jpg)
Deletion - One Child Case
2092
155
10
307
Delete(15)
31
![Page 32: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/32.jpg)
Deletion - Two Child Case
3092
205
10
7
Delete(5)
32
![Page 33: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/33.jpg)
Finally…
3092
207
10
33
![Page 34: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/34.jpg)
Delete Codevoid delete(Comparable key, Node *& root) { Node *& handle(find(key, root)); Node * toDelete = handle; if (handle != NULL) { if (handle->left == NULL) { // Leaf or one child handle = handle->right; } else if (handle->right == NULL) { // One child handle = handle->left; } else { // Two child case Node *& successor(succ(handle)); handle->data = successor->data; toDelete = successor; successor = successor->right; // Succ has <= 1 child } delete toDelete; }} Refs make this short and “elegant”…
but could be done without them with a bit more work.34
![Page 35: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/35.jpg)
Today’s Outline
• Some Tree Review (here for reference, not discussed)
• Binary Trees• Dictionary ADT• Binary Search Trees• Deletion• Some troubling questions
35
![Page 36: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/36.jpg)
Thinking about Binary Search Trees
• Observations– Each operation views two new elements at a time– Elements (even siblings) may be scattered in memory– Binary search trees are fast if they’re shallow
• Realities– For large data sets, disk accesses dominate runtime– Some deep and some shallow BSTs exist for any data
36
![Page 37: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/37.jpg)
Solutions?
• Reduce disk accesses?
• Keep BSTs shallow?
37
![Page 38: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/38.jpg)
To Do
• Continue readings on website!
38
![Page 39: CPSC 221: Data Structures Lecture #5 Branching Out Steve Wolfman 2014W1 1.](https://reader036.fdocuments.us/reader036/viewer/2022062517/56649efc5503460f94c0fb02/html5/thumbnails/39.jpg)
Coming Up
• cilk_spawn Parallelism and Concurrency• cilk_spawn Self-balancing Binary Search Trees• cilk_spawn Priority Queues• cilk_spawn Sorting (most likely!)• Huge Search Tree Data Structure• cilk_join• cilk_join• cilk_join• cilk_join
Spawns parallel task.Since we have only one classroom, one of these goes first!
39