Java * implement a non-member method for the stack adt called
import java.util.EmptyStackException;
import java.util.Iterator;
Save your time - order a paper!
Get your paper written from scratch within the tight deadline. Our service is a reliable solution to all your troubles. Place an order on any task and we will take care of it. You won’t have to worry about the quality and deadlines
Order Paper Nowpublic class Lab07P2Wrapper {
private static boolean equals(int[] arr1, int[] arr2) {
if(arr1.length != arr2.length) return false;
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
public static void main(String[] args) {
int[] example = {-1, 1, 3, 9, 11, 11, 11, 15};
int[] input = {9, 11, 15, 11, 1, -1, 3, 11};
int[] result = stackSort(input);
if(equals(example, result)) {
System.out.println(“Test Passed!”);
} else {
System.out.print(“Test Failed, expected: “);
for(int i = 0; i < example.length; i++) {
if(i == 0) System.out.print(“{” + example[i] + “, “);
else if(i == example.length – 1) System.out.print(example[i] + “}”);
else System.out.print(example[i] + “, “);
}
for(int i = 0; i < result.length; i++) {
if(i == 0) System.out.print(“, got {” + result[i] + “, “);
else if(i == result.length – 1) System.out.print(result[i] + “}”);
else System.out.print(result[i] + “, “);
}
}
}
public static interface Stack<E> {
public void push(E newEntry);
public E pop();
public E top();
public boolean isEmpty();
public int size();
public void clear();
}
public static class SinglyLinkedStack<E> implements Stack<E> {
private static class Node<E> {
private E element;
private Node<E> next;
public Node(E elm, Node<E> next) {
this.element = elm;
this.next = next;
}
public Node(E data) {
this(data, null);
}
public Node() {
this(null, null);
}
public E getElement() {
return element;
}
public Node<E> getNext() {
return next;
}
public void setElement(E elm) {
this.element = elm;
}
public void setNext(Node<E> next) {
this.next = next;
}
public void clear() { // no need to return data
element = null;
next = null;
}
}
// instance variables for the stack object
private Node<E> header; //Note that this is NOT a dummy header
private int currentSize;
public SinglyLinkedStack() {
header = new Node<>();
currentSize = 0;
}
@Override
public void push(E newEntry) {
Node<E> nNode = new Node<>(newEntry, header.getNext());
header.setNext(nNode);
currentSize++;
}
@Override
public E pop() {
E etr = top();
Node<E> ntr = header.getNext();
header.setNext(ntr.getNext());
currentSize–;
ntr.clear();
ntr = null;
return etr;
}
@Override
public E top() {
if (isEmpty())
throw new EmptyStackException();
return header.getNext().getElement();
}
@Override
public boolean isEmpty() {
return size() == 0;
}
@Override
public int size() {
return currentSize;
}
@Override
public void clear() {
while (size() > 0) pop();
}
}
/**
* Implement a non-member method for the Stack ADT called stackSort.
* The function takes as a parameter an array of integers and returns the array sorted in increasing order.
*
* For example consider we have an array A = {9, 11, 15, 11, 1, -1, 3, 11}
* In order to sort values, we will use two stacks which will be called the left and right stacks.
* The values in the stacks will be sorted (in non-descending order) and the values in the left stack
* will all be less than or equal to the values in the right stack.
*
* The following example illustrates a possible state for our two stacks:
*
* left right
* [ ] [ ]
* [ ] [ 9]
* [ 3] [11]
* [ 1] [11]
* [-1] [15]
*
* Notice that the values in the left stack are sorted so that the smallest value is at the bottom of the stack.
* The values in the right stack are sorted so that the smallest value is at the top of the stack.
* If we read the values up the left stack and then down the right stack, we get:
* A = {-1, 1, 3, 9, 11, 11, 11, 15}
* which is in sorted order.
*
*
* Consider the following cases, using the example shown above as a point of reference, to help you design your algorithm:
* 1) If we were to insert the value 5, it could be added on top of either stack and the collection would remain sorted.
* What other values, besides 5, could be inserted in the example without having to move any values?
*
* 2) If we were to insert the value 0, some values must be moved from the left stack to the right stack before we could actually insert 0.
* How many values must actually be moved?
*
* 3) If we were to insert the value 11, first some values must be moved from the right stack to the left stack.
* How many values must actually be moved?
* What condition should we use to determine if enough values have been moved in either of the previous two cases?
*
* YOU MUST USE TWO STACKS, IMPLEMENTATIONS THAT USE Arrays.sort();
* OR ANY SORTING ALGORITHM (BubbleSort, SelectionSort, etc.) WILL NOT BE GIVEN CREDIT
*
* @param array
* @return Sorted array using two stacks
*/
public static int[] stackSort(int[] array) {
/*ADD YOUR CODE HERE*/
return null;
}
}