Algorithm and Data Structures, Supplemental Solution 2010

Transcription

1 Algorithm and Data Structures, Supplemental Solution 00 Question ( marks) (a) marks class Stack { public: void push(int x); int pop(void); bool isempty(); Stack() { top = NULL; void display(); ; private: // define a data structure for linked list nodes. struct Node { int data; Node * next; * top; (b) marks pop() operation linked list implementation The procedure is the same in both cases. Simply store the value from the first node, then set top to top->next. In both cases the procedure is the same

2 Algorithm and Data Structures Supplemental Solution 00 (c) int Stack::pop(){ Node * t = top; int x = top->data; top = top->next; delete t; return x; (d) (e) marks Using a C++ abstract class to represent the ADT Stack. Mention how it can be inherited by two separate stack implementations such as with the linked list and array. and then the client code is decoupled from the implementation class.

3 Algorithm and Data Structures Supplemental Solution 00 Question ( marks) (a) 0 6 i = j i = 0 (b) BubbleSort( int a[], int n) Begin for i = to n- sorted = true for j = 0 to n--i if a[j] > a[j+] temp = a[j] a[j] = a[j+] a[j+] = temp sorted = false end for if sorted break from i loop end for End The highlighted lines in the code will detect whether or not there has been a change in a bubble-pass (no change = array is now sorted) and if there is no change the process is aborted.

4 Algorithm and Data Structures Supplemental Solution 00 (c) marks First transform the unordered array into a partially ordered array, namely a heap. Then start removing from heap value at a time and place value at end of previous heap

5 Algorithm and Data Structures Supplemental Solution 00 And so on

6 Algorithm and Data Structures Supplemental Solution 00 (d) marks i j 9 i j 9 i j 9 i j 9 i j 9 j i 9 9 i j i j i j j i (e) marks Complexity of heap sort = O( n log n ) Expect a few lines saying why this is so. nlog The complexity of both quick sort (on average) and heap sort (always) is given by O( ) which is much less than O(n ) in the case of bubble sort. However, bubble sort may perform like O(n) for nearly sorted arrays. However, the performance of quick sort in certain situations can deteriorate to O(n ). n 6

7 Algorithm and Data Structures Supplemental Solution 00 Question ( marks) (a) Searching for takes calls (b) Binary search is a simple and efficient algorithm for searching a sorted array for a value. If the array a[ ] is of size N, binary search will return a result in at most steps. int binarysearch( int x, int a[ ], int l, int r) Begin // l > r indicates x is not in a[ ] if l > r return j = (l + r) / log if x == a[j] return j // return position where x found else if x < a[j] return binarysearch(x, a, l, j-) else return binarysearch(x, a, j+, r) End N (c) A binary search tree is a recursive dynamic data structure where each tree node is connected to subtrees, a left and right one; with the constraint that the key values in the lh subtree are < node key and node key keys in rh subtree. The subtrees are null or empty trees for leaf nodes. Usually a node will have components, a key value and a data part. The data part may be a data record, a pointer to such or an index into an array of such records. A BST allows for fast access because of the partial ordering. For a well balanced BST of N nodes, a record can be accessed in at most log N steps. However, if a tree becomes unbalanced, its performance can deteriorate to O(N) which is much worse than O(log N) The delete operation is more complicated in a BST and also the BST has to be rebalanced periodically to ensure that its access time remains O(log N)

8 Algorithm and Data Structures Supplemental Solution 00 (d) 9 6 (e) 9 marks Representation: for each node of the tree diagram show the pointers. Also show the head and null nodes. Some of this code expected: void BinTree::insert( int x) { Node * t = new Node(x, z, z); Node * p = head; Node * c = head->r; // find the path down through the tree to a terminal // node where the new node t can be inserted. while(c!= z) { p = c; if(x < c->key) c = c->l; else c = c->r; // insert the node by making a link from the previous // node to it. if(x < p->key) p->l = t; else p->r = t;

9 Algorithm and Data Structures Supplemental Solution 00 Question ( marks) (a) (b) 9

10 Algorithm and Data Structures Supplemental Solution 00 (c) marks AdjLGraph::AdjLGraph(char fname[]) { int j, u, v; Node * t; ifstream f; f.open(fname, ios::in); if(!f) { cout << "\nerror: Cannot open file\n"; return; //Input number of vertices and edges f >> V >> E; adj = new Node*[V+]; visited = new int[v+]; // array to show if vertex // was visited. z = new Node; z->next = z; // null list node for(j=; j<=v; ++j) adj[j] = z; //initially null list //Build graph from text file for(j=; j<=e; ++j) { f >> u >> v; t = new Node; t->vert = v; t->next = adj[u]; adj[u] = t; t = new Node; t->vert = u; t->next = adj[v]; adj[v] = t; 0

11 Algorithm and Data Structures Supplemental Solution 00 (d) marks void AdjLGraph::DFSearch( int s) { int k; id = 0; for(k=; k<=v; ++k) visited[k] = unseen; cout << "\ndepth First Graph Traversal\n"; DFSvisit( s); // start visiting graph vertices using DFS // from starting vertex s // DFS for adjacency lists void AdjLGraph::DFSvisit( int v){ Node *t; visited[v] = ++id; cout << "\n DFS just visited vertex " << v; for( t = adj[v]; t!= z; t = t->next) if( visited[t->vert] == unseen) DFSvisit(t->vert); Depth First Traversal visits vertices in order:,,, 6,,,.

12 Algorithm and Data Structures Supplemental Solution 00 (e) marks Graph :: DFS_iter( Vertex s) Begin Stack s id = 0 for v = to V visited[v] = 0 s.push(s) while (not s.isempty()) v = s.pop() if (not visited[v]) visited[v] = ++id for each vertex u adj(v) if (not visited[u]) s.push(u) End end while To change this to breadth first, use a queue rather than a stack.