MIDTERM WEEK - 9. Question 1 : Implement a MyQueue class which implements a queue using two stacks.

Transcription

1 Ashish Jamuda Week 9 CS 331-DATA STRUCTURES & ALGORITHMS MIDTERM WEEK - 9 Question 1 : Implement a MyQueue class which implements a queue using two stacks. Solution: Since the major difference between a queue and a stack is the order (first-in-first-out vs. lastin-first-out), we know that we need to modify peek() and pop() to go in reverse order. We can use our second stack to reverse the order of the elements (by popping s1 and pushing the elements on to s2). In such an implementation, on each peek() and pop() operation, we would pop everything from s1 onto s2, perform the peek / pop operation, and then push everything back. This will work, but if two pop / peeks are performed back-to-back, we re needlessly moving elements. We can implement a lazy approach where we let the elements sit in s2. s1 will thus be ordered with the newest elements on the top, while s2 will have the oldest elements on the top. We push the new elements onto s1, and peek and pop from s2. When s2 is empty, we ll transfer all the elements from s1 onto s2, in reverse order. public class MyQueue<T> { Stack<T> s1, s2; public MyQueue() { s1 = new Stack<T>(); s2 = new Stack<T>(); public int size() { return s1.size() + s2.size(); public void add(t value) { s1.push(value); CS 331 Week 9 Page 1

2 public T peek() { if (!s2.empty()) return s2.peek(); while (!s1.empty()) s2.push(s1.pop()); return s2.peek(); public T remove() { if (!s2.empty()) return s2.pop(); while (!s1.empty()) s2.push(s1.pop()); return s2.pop(); Question 2 : Write an algorithm to find the next node (e.g., in-order successor) of a given node in a binary search tree where each node has a link to its parent. Solution: We approach this problem by thinking very, very carefully about what happens on an inorder traversal. On an in-order traversal, we visit X.left, then X, then X.right. So, if we want to find X.successor(), we do the following: 1. If X has a right child, then the successor must be on the right side of X (because of the order in which we visit nodes). Specifically, the left-most child must be the first node visited in that subtree. 2. Else, we go to X s parent (call it P). 2.a. If X was a left child (P.left = X), then P is the successor of X 2.b. If X was a right child (P.right = X), then we have fully visited P, so we call successor(p). public static TreeNode inordersucc(treenode e) { if (e!= null) { CS 331 Week 9 Page 2

3 TreeNode p; // Found right children -> return 1st inorder node on right if (e.parent == null e.right!= null) { p = leftmostchild(e.right); else { // Go up until we re on left instead of right (case 2b) while ((p = e.parent)!= null) { if (p.left == e) { break; e = p; return p; return null; public static TreeNode leftmostchild(treenode e) { if (e == null) return null; while (e.left!= null) e = e.left; return e; Question 3 : Given a binary search tree, design an algorithm which creates a linked list of all the nodes at each depth (eg, if you have a tree with depth D, you ll have D linked lists). CS 331 Week 9 Page 3

4 Solution: We can do a simple level by level traversal of the tree, with a slight modification of the breath- first traversal of the tree. In a usual breath first search traversal, we simply traverse the nodes without caring which level we are on. In this case, it is critical to know the level. We thus use a dummy node to indicate when we have finished one level and are starting on the next. ArrayList<LinkedList<TreeNode>> findlevellinklist(treenode root) { int level = 0; ArrayList<LinkedList<TreeNode>> result = new ArrayList<LinkedList<TreeNode>>(); LinkedList<TreeNode> list = new LinkedList<TreeNode>(); list.add(root); result.add(level, list); while (true) { list = new LinkedList<TreeNode>(); for (int i = 0; i < result.get(level).size(); i++) { TreeNode n = (TreeNode) result.get(level).get(i); if (n!= null) { if(n.left!= null) list.add(n.left); if(n.right!= null) list.add(n.right); if (list.size() > 0) { result.add(level + 1, list); else { CS 331 Week 9 Page 4

5 break; level++; return result; Question 4: Given a sorted (increasing order) array, write an algorithm to create a binary tree with minimal height. Solution: We will try to create a binary tree such that for each node, the number of nodes in the left subtree and the right subtree are equal, if possible. Algorithm: 1. Insert into the tree the middle element of the array. 2. Insert (into the left subtree) the left subarray elements 3. Insert (into the right subtree) the right subarray elements 4. Recurse public static TreeNode addtotree(int arr[], int start, int end){ if (end < start) { return null; int mid = (start + end) / 2; TreeNode n = new TreeNode(arr[mid]); n.left = addtotree(arr, start, mid - 1); n.right = addtotree(arr, mid + 1, end); return n; CS 331 Week 9 Page 5

6 public static TreeNode createminimalbst(int array[]) { return addtotree(array, 0, array.length - 1); Question 5: Write a program to sort a stack in ascending order. You should not make any assumptions about how the stack is implemented. The following are the only functions that should be used to write this program: push pop peek isempty. Solution: Sorting can be performed with one more stack. The idea is to pull an item from the original stack and push it on the other stack. If pushing this item would violate the sort order of the new stack, we need to remove enough items from it so that it s possible to push the new item. Since the items we removed are on the original stack, we re back where we started. The algorithm is O(N^2) and appears below. public static Stack<Integer> sort(stack<integer> s) { Stack<Integer> r = new Stack<Integer>(); while(!s.isempty()) { int tmp = s.pop(); while(!r.isempty() && r.peek() > tmp) { s.push(r.pop()); r.push(tmp); return r; CS 331 Week 9 Page 6