CS 106B Practice Final Exam #8 (15au) ANSWER KEY

Transcription

1 1. Linked Lists (write) CS 106B Practice Final Exam #8 (15au) ANSWER KEY // solution 1 void LinkedIntList::partitionSort() { if (!front) { return; // empty list case ListNode* current = front; while (current->next!= NULL) { if (current->next->data < 0) { // negative value; move to front of list ListNode* temp = current->next; current->next = current->next->next; temp->next = front; front = temp; else { // <--!!! THIS ELSE HERE IS REALLY IMPORTANT!!! // non-negative value; leave in place and move to next current = current->next; ////////////////////////////////////////////////////////////////////////////////////// // solution 2: build up separate positive and negative chains void LinkedIntList::partitionSort() { ListNode* negativefront = NULL; // front/end of chain of negative numbers ListNode* negativeend = NULL; ListNode* positivefront = NULL; ListNode* positiveend = NULL; ListNode* current = front; while (current!= NULL) { // front/end of chain of non-negative numbers ListNode* temp = current->next; if (current->data < 0) { // negative value; add to front of negative chain if (negativeend == NULL) { negativeend = current; current->next = negativefront; negativefront = current; else { // non-negative value; add to end of positive chain if (positivefront == NULL) { positivefront = current; else { positiveend->next = current; positiveend = current; current->next = NULL; current = temp; // go to next if (negativefront == NULL) { // combine the chains (negatives, then positives) front = positivefront; else { front = negativefront; negativeend->next = positivefront; 1 of 8

2 2. Heaps (read) a) after enqueue operations: CS 106B Practice Final Exam #8 (15au) ANSWER KEY {, K:1, H:2, F:5, A:6, J:3, L:9, G:12, B:10, I:8, D:7, E:4, C:11 as tree: K:1 H:2 F:5 A:6 J:3 L:9 G:12 / B:10 I:8 D:7 E:4 C:11 b) after two dequeue operations: 1) {, H:2, J:3, F:5, A:6, E:4, L:9, G:12, B:10, I:8, D:7, C:11 2) {, J:3, E:4, F:5, A:6, D:7, L:9, G:12, B:10, I:8, C:11 as tree: J:3 E:4 F:5 A:6 D:7 L:9 G:12 / B:10 I:8 C:11 2 of 8

3 3. Binary Trees (read) (a) after adding all values: Gideon Darlene Romero Angela FSociety MrRobot Shayla \ Elliot Ollie Tyrell / Trenton (b) No, overall tree is not balanced. Unbalanced node: Shayla (c) after removing Angela, Darlene, and Gideon: Either of the two trees below. option 1: MrRobot FSociety Romero / Elliot Ollie Shayla \ Tyrell / Trenton =================================================== option 2: FSociety Elliot Romero MrRobot Shayla \ \ Ollie Tyrell / Trenton 3 of 8

4 4. Binary Trees (write) // solution 1 bool BinaryTree::isConsecutive() const { int prev = 0; // initial value can be anything; will be overwritten bool first = true; return isconsecutivehelper(root, prev, first); // Recursive helper to implement isconsecutive behavior. // The idea is that we will visit the tree's nodes in-order, going left-center-right, // and as we mark each node we'll grab its value and call it 'prev'. The next time // we mark a node, we'll compare its value to 'prev' to make sure they differ by // exactly 1. The purpose of the 'first' parameter is to know whether we're in the // case of marking the very first node in the traversal, in which case there is no // 'previous' value to compare against. bool isconsecutivehelper(treenode* node, int& prev, bool& first) { if (node == NULL) { // base case: trivially true return true; else { // in-order traversal: // (1) explore the left; if it is not sequential, stop if (!isconsecutivehelper(node->left, prev, first)) { return false; // (2) examine the current node if (first) { // If this is the first node marked in my in-order traversal, // prev doesn't have a meaningful value, so set it. prev = node->data; first = false; else { // This is not the first node I've marked; make sure it is sequential // with the last node I marked. if (prev + 1!= node->data) { return false; // (3) explore the right prev = node->data; return isconsecutivehelper(node->right, prev, first); 4 of 8

5 5. Graphs (write) // solution 1 Vector<Vertex*> findeulerpath(basicgraph& graph) { Vector<Vertex*> path; if (graph.isempty() graph.getedgeset().isempty()) { return path; // special case: return empty path // try to find an Euler path starting from each vertex for (Vertex* v : graph) { graph.resetdata(); path.add(v); if (findeulerpathhelper(graph, v, path)) { return path; path.clear(); // no Euler path found return path; // searches for the longest path (most edges) starting from v bool findeulerpathhelper(basicgraph& graph, Vertex* v, Vector<Vertex*>& path) { if (path.size() == graph.getedgeset().size() / 2 + 1) { return true; // base case: found Euler circuit if start = end else { // recursive case: for each unused edge: choose, explore, unchoose for (Edge* edge : graph.getedgeset(v)) { if (!edge->visited) { // choose edge->visited = true; // Edge* partner = graph.getedge(edge->finish, edge->start); // partner->visited = true; path.add(edge->finish); return false; // explore if (findeulerpathhelper(graph, edge->finish, path)) { return true; else { // unchoose edge->visited = false; // partner->visited = false; path.remove(path.size() - 1); ////////////////////////////////////////////////////////////////////////////////////// 5 of 8

6 6. Hashing (read) [ 0]: [ 1]: [ 2]: -> 82:59 -> 22:66 [ 3]: [ 4]: [ 5]: [ 6]: [ 7]: -> 47:74 -> 7:555 [ 8]: [ 9]: [10]: [11]: [12]: [13]: [14]: -> 14:8 -> 74:222 [15]: [16]: [17]: -> 57:75 [18]: [19]: -> 79:0 -> 99:5 size = 9 capacity = 20 load factor = of 8

7 7. Inheritance and Polymorphism (read) var1->m1(); var1->m2(); var2->m1(); var2->m2(); var2->m3(); var3->m1(); var3->m2(); var3->m3(); var4->m1(); var4->m4(); ((Burr*) var1)->m3(); ((Eliza*) var2)->m4(); ((George*) var4)->m4(); ((Eliza*) var3)->m3(); ((George*) var2)->m4(); // H1 H2 B1 // H2 // H1 E2 H2 B1 // E2 H2 // COMPILER ERROR // H1 E2 H2 B1 // E2 H2 // B3 E3 // G1 H1 E2 H2 B1 // COMPILER ERROR // B3 // COMPILER ERROR // G4 E2 H2 // B3 E3 // CRASH (RUNTIME ERROR) 7 of 8

8 8. Inheritance / ArrayList (write) // SortedList.h class SortedList : public ArrayList { public: SortedList(bool unique); virtual void add(int value); virtual void insert(int index, int value); virtual bool isunique() const; virtual void set(int index, int value); private: bool unique; ; ////////////////////////////////////////////////////////////////////////////////////// // SortedList.cpp SortedList::SortedList(bool value) { unique = value; void SortedList::add(int value) { // figure out index to insert this value int index; for (index = 0; index < size(); index++) { if (get(index) > value) { break; else if (get(index) == value) { if (unique) { return; // don't add if duplicate and 'unique' flag is on else { break; // use superclass's insert method to add the item at the right index ArrayList::insert(index, value); void SortedList::insert(int index, int value) { add(value); bool SortedList::isUnique() const { return unique; void SortedList::set(int index, int value) { throw "set() is not supported in SortedList"; // add method, solution 2 (less efficient but still ok) void SortedList::add(int value) { if (unique) { // check if it is already here; if so, don't add for (int i = 0; i < size(); i++) { if (get(i) == value) { return; // add at end, then shift into proper place ArrayList::add(value); for (int i = size() - 1; i > 0; i--) { int e1 = get(i); int e2 = get(i - 1); if (e1 < e2) { ArrayList::set(i - 1, e1); // out of order, so swap ArrayList::set(i, e2); Copyright Stanford University and Marty Stepp. Licensed under Creative Commons Attribution 2.5 License. All rights reserved. 8 of 8