CS 261 – Recitation 9 & 10 Graphs & Final review Fall 2013 Oregon State University School of...
Preview:
Citation preview
- Slide 1
- CS 261 Recitation 9 & 10 Graphs & Final review Fall
2013 Oregon State University School of Electrical Engineering and
Computer Science
- Slide 2
- 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
- Slide 3
- 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
- Slide 4
- 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.
- Slide 5
- CS 261 Data Structures 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. 5
- Slide 6
- CS 261 Data Structures Question 6 H J D C G B K F A I E
- Slide 7
- 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 Postorder: 1 6 7 8 5 40
60 56 34 10 CS 261 Data Structures7
- Slide 8
- Adding 13??? CS 261 Data Structures8 13
- Slide 9
- Removing 10??? CS 261 Data Structures9
- Slide 10
- 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 Structures10
- Slide 11
- 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++) addAVLTree(tree, data[i]); /*
call the helper function */ _treeSortHelper(tree->root, data,
&count); } CS 261 Data Structures11
- Slide 12
- _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 Structures12
- Slide 13
- True or False CS 261 Data Structures13
- Slide 14
- Question Add 12, remove 3, remove 5 CS 261 Data
Structures14
- Slide 15
- 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: Ns BF is positive and Ns right subtrees BF
is negative Ns BF is negative and Ns left subtrees BF is positive.
CS 261 Data Structures15
- Slide 16
- Draw the stack of in-order traversal using iterator if stack is
empty perform slide left on root otherwise let n be top of stack
pop n slide left on right child of n CS 261 Data Structures16
- Slide 17
- 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? What is the index
of the parent of a node at index i? CS 261 Data Structures 17 2 5 8
3 7910 14121116 0202 1313 2525 3939 4 10 5757 6868 7 14 8 12 9 11
10 16 2 * i + 1, 2 * i + 2 (i-1)/2
- Slide 18
- Simulate heap sort for the following heap CS 261 Data
Structures18 3 9 10 141211 16