### Recitation 10 - Classes - Oregon State University

```Oregon State University
School of Electrical Engineering and Computer Science
CS 261 – Recitation 9 & 10
Graphs & Final review
Fall 2013
Graph: Reachability Problem
• Given a single starting vertex, produce the set of vertices
that can be reached starting from the initial location.
• A depth-first search follows each path as far (deep) as
possible before backtracking.
• A breadth-first search looks at all possible paths at the
same time.
Order in which nodes are reached: (left) DFS; and (right)
BFS. Source: Wikipedia
Graph: Reachability Problem
findReachable (graph g, vertex start) {
create a set of reachable vertices, initially empty. call this r.
create a container for vertices known to be reachable. call this c
add start vertex to container c
while the container c is not empty {
remove first entry from the container c, assign to v
if v is not already in the set of reachable vertices r {
add v to the reachable set r
add the neighbors of v to the container c
}
}
return r
}
DFS: Container is a Stack
BFS: Container is a Queue
Exercise
Simulate the DFS and BFS on the following graph starting at
node A.
Notes: (1) Nodes must be added to the container (Stack or
Queue) in COUNTER-CLOCKWISE order; (2) We do not add
neighbors to the container if they have already been visited.
Outline – Final exam review
• BST/AVL/Tree sort/Tree traversal/Tree iterator
• Heaps/heap sort
• Hash tables
Materials in these slides were collected from different
Internet sources.
CS 261 – Data Structures
5
Question
H
J
D
F
B
A
C
E
I
K
G
CS 261 – Data Structures
6
Pre, In, Post-order traversal
Pre-order:
10 – 5 – 1 – 8 – 7 – 6 – 34 –
56 – 40 - 60
In-order:
1 – 5 – 6 – 7 – 8 – 10 – 34 –
40 – 56 - 60
Post–order:
1 – 6 – 7 – 8 – 5 – 40 – 60 –
56 – 34 – 10
CS 261 – Data Structures
7
13
CS 261 – Data Structures
8
Removing 10???
CS 261 – Data Structures
9
TreeSort
struct AVLTree* newAVLTree();
void addAVLTree(struct AVLTree *tree, TYPE val);
void treeSort (TYPE data[], int n) {…}
void _treeSortHelper(AVLNode *cur, TYPE *data, int *count)
{…}
CS 261 – Data Structures
10
treeSort
void treeSort(TYPE data[], int n){
int i; int count = 0;
/* declare an AVL tree */
struct AVLTree *tree = newAVLtree();
assert(data != NULL && n > 0);
/* add elements to the tree */
for (i = 0; i < n; i++)
/* call the helper function */
_treeSortHelper(tree->root, data, &count);
}
CS 261 – Data Structures
11
_treeSortHelper
/* *count goes from 0 to n-1 */
void _treeSortHelper(AVLNode *cur, TYPE *data, int *count){
if (cur != NULL) {
_treeSortHelper(cur->left, data, count);
data[*count] = cur->val;
(*count)++;
_treeSortHelper(cur->right, data, count);
}
}
CS 261 – Data Structures
12
True or False
CS 261 – Data Structures
13
Question
• Add 12, remove 3, remove 5
CS 261 – Data Structures
14
When to do a double rotation?
Balance Factor = height(right subtree) - height(left subtree)
• At an unbalanced node N, a double rotation is needed
when:
– N’s BF is positive and N’s right subtree’s BF is
negative
– N’s BF is negative and N’s left subtree’s BF is positive.
CS 261 – Data Structures
15
Heaps and priority queues
• How to represent a binary heap?
– Using an array (dyArray)
• Suppose the root has index 0, what are the indices of the 2 children of
a node at index i? 2 * i + 1, 2 * i + 2
• What is the index of the parent of a node at index i? (i-1)/2
2
3
5
9
14
10
12
11
7
16
8
0
1
2
3
4
5
6
2
3
5
9 10
7
8 14 12 11 16
CS 261 – Data Structures
7
8
9
10
17
Simulate heap sort for the following heap
3
10
9
14
12
11
CS 261 – Data Structures
16
18
```