Using this Node class below complete the stack class(which is below the Node class by adhering to the comments) to get the yays. You may not add additional methods or change the method signatures in the set class. class Node { private T value; private Node next; private Node prev; public Node(T value) { this.value = value; } public T getValue() { return value; } public void setValue(T value) { this.value = value; } public Node getNext() { return this.next; } public void setNext(Node next) { this.next = next; } public Node getPrev() { return this.prev; } public void setPrev(Node prev) { this.prev = prev; } public static String listToString(Node head) { StringBuilder ret = new StringBuilder(); Node current = head; while(current != null) { ret.append(current.value); ret.append(" "); current = current.getNext(); } return ret.toString().trim(); } public static String listToStringBackward(Node head) { Node current = head; while(current.getNext() != null) { current = current.getNext(); } StringBuilder ret = new StringBuilder(); while(current != null) { ret.append(current.value); ret.append(" "); current = current.getPrev(); } return ret.toString().trim(); } public static void main(String[] args) { //main method for testing, edit as much as you want //make nodes Node n1 = new Node<>("A"); Node n2 = new Node<>("B"); Node n3 = new Node<>("C"); //connect forward references n1.setNext(n2); n2.setNext(n3); //connect backward references n3.setPrev(n2); n2.setPrev(n1); //print forward and backward System.out.println(Node.listToString(n1)); System.out.println(Node.listToStringBackward(n1)); } } 

import javax.xml.soap.Node; import java.util.Iterator; class CallStack implements Iterable { // You'll want some instance variables here //Create a linkedlist Node -item, value-value of the item. //LIFO public CallStack() { } public void push(T item) { //push an item onto the stack //you may assume the item is not null //O(1) } /** * Return item on top. * Size will be reduced. * @return */ public T pop() { //pop an item off the stack //if there are no items on the stack, return null //O(1) //replace this dummy return statement return null; } /** * Return the item on top. * @return */ public T peek() { //return the top of the stack (but don't remove it) //if there are no items on the stack, return null //O(1) //replace this dummy return statement return null; } public String toString() { //Create a string of the stack where each item //is separated by a space. The top of the stack //should be shown to the right and the bottom of //the stack on the left. //Hint: Reuse the provided code from another class //instead of writing this yourself! //O(n) //replace this dummy return statement return null; } public void clear() { //remove everything from the stack //O(1) } public int size() { //return the number of items on the stack //O(1) //replace this dummy return statement return size; } public boolean isEmpty() { //return whether or not the stack is empty //O(1) //replace this dummy return statement return false; } @SuppressWarnings("unchecked") public Object[] toArray() { //Return an array representation of the stack. //The top of the stack should be element 0 //in the array. //O(n) //replace this dummy return statement return null; } /** * * @return the top element. Make sure the top element gets updated. */ public Iterator iterator() { //Return an iterator that traverses from //the top of the stack to the bottom of //the stack. //The iterator's hasNext() and next() methods //must both be O(1) //next() should throw a NullPointerException //if you try to use next when there are no //more items //replace this dummy return statement return null; } public static void main(String[] args) { CallStack s1 = new CallStack<>(); s1.push("a"); s1.push("b"); CallStack s2 = new CallStack<>(); s2.push(1); s2.push(2); s2.push(3); if(s1.toString().equals("a b") && s1.toArray()[0].equals("b") && s1.toArray()[1].equals("a") && s1.toArray().length == 2) { System.out.println("Yay 1"); } if(s1.peek().equals("b") && s2.peek().equals(3) && s1.size() == 2 && s2.size() == 3) { System.out.println("Yay 2"); } if(s1.pop().equals("b") && s2.pop().equals(3) && s1.size() == 1 && s2.size() == 2) { System.out.println("Yay 3"); } if(s1.toString().equals("a") && s1.peek().equals("a") && s2.peek().equals(2) && s1.pop().equals("a") && s2.pop().equals(2) && s1.size() == 0 && s2.size() == 1) { System.out.println("Yay 4"); } if(s1.toString().equals("") && s1.peek() == null && s2.peek().equals(1) && s1.pop() == null && s2.pop().equals(1) && s1.size() == 0 && s2.size() == 0) { System.out.println("Yay 5"); } s2.push(10); s2.push(20); s2.push(30); if(s1.isEmpty() && s1.toArray().length == 0 && !s2.isEmpty()) { s2.clear(); if(s2.isEmpty()) { System.out.println("Yay 6"); } } CallStack s3 = new CallStack<>(); s3.push(3); s3.push(2); s3.push(1); int i = 1; for(Integer item : s3) { if(i == item) System.out.println("Yay " + (6+i)); else System.out.println(item); i++; } } }