Data Structures and Algorithms, Winter term 2018 Practice Assignment 3

Transcription

1 German University in Cairo Media Engineering and Technology Prof. Dr. Slim Abdennadher Dr. Wael Abouelsaadat Data Structures and Algorithms, Winter term 2018 Practice Assignment 3 Exercise 3-1 Search in a Stack Write a method to find the position of a given element in a stack counting from the top of the stack. More precisely, the method should return 0 if the element occurs on the top, 1 if there is another element on top of it, and so on. If the element occurs several times, the topmost position should be returned. If the element doesn t occur at all, -1 must be returned. You are asked to write this method in two different ways; one way is to implement it internally inside the ArrayStack class and the other way is to implement it externally in a separate class. Important: At the end the stack should be returned to the original state (i.e. no elements should be removed and the order of the elements should not change). a) Internal method public class ArrayStack private int[] thestack; private int maxsize; private int top; public ArrayStack(int s) maxsize = s; thestack = new int[maxsize]; top = -1; public void push(int elem) top++; thestack[top] = elem; public int pop() int result = thestack[top]; top--; return result; public int top() return thestack[top]; public boolean isfull() return (top == (maxsize-1) ); public boolean isempty() 1

2 return (top == -1); public int size() return (top+1); public void printstack() if(top == -1) System.out.println("Stack is empty!!\n"); else System.out.println(theStack[top]+" <- top"); for(int i=top-1; i>=0; i--) System.out.println(theStack[i]); System.out.println(); //Exercise 3-1, internal implementation public int search(int target) for (int i = top; i >= 0 ; i--) if(thestack[i] == target) return top -i; return -1; b) External method public class StackSearching //Exercise 3-1, external implementation public static int searchfor(arraystack s1,int target) int position = 0; boolean found = false; //will be used to return s1 to its original state ArrayStack s2 = new ArrayStack(s1.size()); //search while (!(s1.isempty())) if(s1.top() == target) found = true; break; s2.push(s1.pop()); position ++; //return s1 to its original state while((!(s2.isempty())) && (!(s1.isfull())) ) s1.push(s2.pop()); if(!found) position = -1; return position; public static void main(string[] args) ArrayStack s = new ArrayStack(10); s.push(4); 2

3 s.push(20); s.push(7); s.push(1); System.out.println(12+": internally "+ s.search(12)+", externally: "+ searchfor(s, 12)); System.out.println(1+": internally "+ s.search(1)+", externally: "+ searchfor(s, 1)); System.out.println(20+": internally "+ s.search(20)+", externally: "+ searchfor(s, 20)); Exercise 3-2 Stack Decompose You are required to implement a method public static ArrayStack decompose(arraystack x) where x is a stack of ints. The method is required to decompose the values stored in the stack x into two groups: values in the odd positions remain in the stack x values in the even positions should be stored in a new stack, say y The method should finally return the newly created stack y containing the values in the even positions. We will assume that the value on top of the stack is in position 1. Make sure that the order of elements in both stacks will remain the same as the order of elements in the initial stack. The following is a sample method run: Input: x Effect of method: x y Only stacks can be used!. Implement the method decompose externally, i.e. using the methods available in the stack class. public class StackDecompose public static ArrayStack decompose(arraystack x) ArrayStack y = new ArrayStack(x.size()/2); ArrayStack odd = new ArrayStack(x.size()/2+1); ArrayStack even = new ArrayStack(x.size()/2); while(!x.isempty()) odd.push(x.pop()); if(!x.isempty()) even.push(x.pop()); while(!odd.isempty()) 3

4 x.push(odd.pop()); while(!even.isempty()) y.push(even.pop()); return y; //alternative solution public static ArrayStack decompose2(arraystack x) ArrayStack reverse = new ArrayStack(x.size()); ArrayStack y = new ArrayStack(x.size()/2); boolean isoddsized = x.size()%2 == 1; while(!x.isempty()) reverse.push(x.pop()); while(!reverse.isempty()) if(isoddsized) x.push(reverse.pop()); if(!reverse.isempty()) y.push(reverse.pop()); else y.push(reverse.pop()); x.push(reverse.pop()); return y; public static void main(string[] args) ArrayStack s = new ArrayStack(8); s.push(6); s.push(9); s.push(5); s.push(4); s.push(1); s.push(2); s.push(7); ArrayStack y = decompose2(s); y.printstack(); Exercise 3-3 To be discussed in the Tutorial Stack Sorting Write an external method to sort a stack by putting the smaller elements towards the bottom. public class StackSort public static void stacksort(arraystack s1) int count = s1.size(); ArrayStack s2 = new ArrayStack(count); int tmp; while (count>0) int min = s1.pop(); for (int i =1; i<count; i++) 4

5 tmp = s1.pop(); if (tmp<min) s2.push(min); min = tmp; else s2.push (tmp); s1.push(min); while(!s2.isempty()) s1.push(s2.pop()); count--; public static void main(string[] args) ArrayStack s = new ArrayStack(8); s.push(6); s.push(9); s.push(5); s.push(4); s.push(1); s.push(2); s.push(7); stacksort(s); Exercise 3-4 Cube Game For this problem you are going to implement a method for a simple game. In this game you are given a stack of cubes which can only be accessed from the top. You are required to determine whether the sum of the elements in the top half of the stack is equal to the sum of the elements in the bottom half. If the number of elements is odd, ignore the middle element. You have to end your check with the contents of the stack being in the same order as they were given to you. For the purpose of this problem implement the method static boolean check(arraystack x), which performs the check operation described above over a stack x of integers and returns true if both halves are equal and false otherwise. Note: you are not allowed to use any data structure except stacks for solving this problem. Sample run: Input: Output: true, with = = 12 Input: Output: false, with

6 public class CubeGame public static boolean check(arraystack s) int size = s.size(); int sum1=0; int sum2=0; int x; ArrayStack temp=new ArrayStack(size); // popping the first half for(int i = 0; i < size / 2; i++) x = s.pop(); sum1 += x; temp.push(x); // in the case of an odd-sized stack if(size % 2 == 1) temp.push(s.pop()); // popping the second half for(int i = 0; i < size / 2; i++) x = s.pop(); sum2 += x; temp.push(x); // returning back the elements while(!temp.isempty()) s.push(temp.pop()); return sum1 == sum2; public static void main(string args[]) ArrayStack s = new ArrayStack(5); s.push(9); s.push(8); s.push(8); s.push(4); System.out.println(check(s)); Exercise 3-5 Reverse a Stack For this exercise, you are required to reverse the contents of a Stack. Use the ArrayStack implementation posted on the website. a) First do it internally, i.e. as an instance method inside the ArrayStack class Add this instance method to the ArrayStack class: public void reverse() for(int i=0; i<(top+1)/2; i++) int temp = thestack[i]; thestack[i] = thestack[top-i]; thestack[top-i] = temp; 6

7 b) Then do it externally, you should implement 3 external methods: 1. Write a method static ArrayStack reverse1(arraystack s) that takes a stack as a parameter and returns its reverse, you are allowed to destruct the original stack. 2. Write a method static ArrayStack reverse2(arraystack s) that takes a stack as a parameter and returns its reverse, but this time at the end the stack should be returned to the original state. 3. Write a method static void reverse3(arraystack s) that takes a stack as a parameter and reverses it and puts the reversed stack in the original. You should display the stack elements before and after calling each method. public class ReverseStack public static ArrayStack reverse1(arraystack s) ArrayStack result = new ArrayStack(s.size()); while(!s.isempty()) result.push(s.pop()); return result; public static ArrayStack reverse2(arraystack s) ArrayStack result = new ArrayStack(s.size()); ArrayStack tmp = new ArrayStack(s.size()); while(!s.isempty()) tmp.push(s.top()); result.push(s.pop()); while(!tmp.isempty()) s.push(tmp.pop()); return result; public static void reverse3(arraystack s) ArrayStack s1=new ArrayStack(s.size()); ArrayStack s2=new ArrayStack(s.size()); while(!s.isempty()) s1.push(s.pop()); while(!s1.isempty()) s2.push(s1.pop()); while(!s2.isempty()) s.push(s2.pop()); public static void main(string[] args) ArrayStack s = new ArrayStack(5); s.push(5); s.push(44); System.out.println("Original Stack before reverse:"); ArrayStack r = reverse1(s); System.out.println("Original Stack after reverse:"); System.out.println("Reverse Stack:"); 7

8 r.printstack(); s.push(5); s.push(44); System.out.println("Original Stack before reverse:"); r = reverse2(s); System.out.println("Original Stack after reverse:"); System.out.println("Reverse Stack:"); r.printstack(); System.out.println("Original Stack before reverse:"); reverse3(s); System.out.println("Original Stack after reverse:"); 8

9 Exercise 3-6 Remove n th Element You are given a stack with the methods pop, push, top, isempty, isfull and size. You are required to implement a method static void removenth(arraystack s, int n) which removes the n th element from the bottom of the stack s. Assume that the value of n will be between 1 and size of the given stack, inclusive. For instance, the call removenth(s, 1) should remove the lowermost item of the stack s. The stack s should be unchanged except for the deleted element. You may only use stacks to solve this problem. Do not re-implement the stack operations. public class RemovingNthStack public static void removenth(arraystack s, int n) int size = s.size(); ArrayStack temp = new ArrayStack(size); for(int i=0; i<size-n; i++) temp.push(s.pop()); if(!s.isempty()) s.pop(); while(!temp.isempty()) s.push(temp.pop()); public static void main(string[] args) ArrayStack s= new ArrayStack(5); s.push(1); s.push(5); s.push(23); s.push(8); s.push(2); removenth(s, 3); Exercise 3-7 Midterm Exam 2015 Suppose we have a stack of integers. Initially the integers are not sorted. We would like to rearrange the stack using the insertion sort algorithm presented in lectures for arrays. The elements should be in ascending order where the smallest element will be on top of the stack and the largest at the bottom of the stack. a) Write an external Java method void stacksort(objectstack s) that takes a stack of integers s and sorts the stack based on the insertion sort algorithm for arrays. Please note that you are not allowed to use except stacks and the following constructor and methods: public ObjectStack(int maxsize) public void push(object o) public Object pop() public Object top() public boolean isempty() public boolean isfull() public int size() public class Ex2 public static void stacksort1(stackobj s) // create two new empty stacks 9

10 StackObj x = new StackObj(s.size()); StackObj y = new StackObj(s.size()); // loop on all unsorted elements while (!s.isempty()) int tmp = (Integer) s.pop(); // the first element if (x.isempty()) x.push(tmp); else while (!x.isempty()&&(integer)x.top()>tmp) y.push(x.pop()); x.push(tmp); // return elements to their position while (!y.isempty()) x.push(y.pop()); // put the sorted elements in stack (s) again while (!x.isempty()) s.push(x.pop()); /* Another solution */ public static void stacksort2(stackobj s) // create two new empty stacks StackObj x = new StackObj(s.size() - 1); StackObj y = new StackObj(s.size() - 1); while (s.size() > 1) // move all elements except the first element x.push(s.pop()); // loop on all moved elements while (!x.isempty()) // the element is in its correct position if ((Integer) s.top() > (Integer) x.top()) s.push(x.pop()); else while(!s.isempty()&& (Integer)s.top()<(Integer)x.top()) y.push(s.pop()); s.push(x.pop()); // return elements to their position while (!y.isempty()) s.push(y.pop()); public static void main(string[] args) StackObj s = new StackObj(4); s.push(1); s.push(4); s.push(2); stacksort1(s); b) Given an initially unordered stack 10

11 1. What is the best case complexity of the algorithm? Justify your answer. 4cm Best Case O(n), because there will be only one element out of place, therefore the loop will execute n times and the inner loop will be executed only once. 2. What is the worst case complexity of the algorithm? Justify your answer. 4cm Worst Case O(n 2 ), because all elements will be out of place and both nested loops will be executed n times 3. What is the invariant of the algorithm? Justify your answer. The invariant: After n passes, n elements are partially sorted. because in each iteration we insert one of the unsorted elements in its correct position. 11