I need help implementing a Stack with this java programming assignment: Given a doubly linked list (code provided below) implement a Stack. You must use the doubly link list class and utilize it as an object in your implementation of the stack. A Stack is a Last in First Out (LiFO) structure which translates to the processes of outputting the last element which was inputted in the collection. The Stack is based on the process of putting things on top of one another and taking the item on top (think of a stack of papers). Operations to implement: push (E): Add an element to the start of the sequence pop: Remove an element from the start of the sequence Peek: Return the first element of the sequence without removing it atIndex(x): Return the element at the given index (x) Or throw an exception if it is out of bound (if you can control the user input then do that instead) Size: Return the size of the Stack isEmpty: Boolean, returns true if the Stack is empty Empty: Empty the Stack Code Part 1: public class DoublyLinkedList{ private DNode head; private DNode tail; private int size; public DoublyLinkedList(){ // construct an empty list this.tail = new DNode (null, null, this.head); this.head = new DNode (null, this.tail, null); this.size = 0; } public DoublyLinkedList(DNode next){ // constructs a list // out of a single node this.tail = new DNode (null, null, next); this.head = new DNode (null, next, null); next.changeNext(this.tail); next.changePrev(this.head); this.size = 1; } public DoublyLinkedList(Object [] objectArray){ // construct a list out of // an array this.tail = new DNode (null, null, this.head); this.head = new DNode (null, this.tail, null); DNode temp = this.head; for (Object e : objectArray) { //Anonomus function new DNode (e, temp.getNext(),temp).insertBetweenNodes(temp, temp.getNext()); temp = temp.getNext(); this.size += 1; } } public void addToFrontofList(Object toAdd){ // Appends the begining // of the list DNode temp = new DNode (toAdd, this.head.getNext(), this.head); this.head.getNext().changePrev(temp); this.head.changeNext(temp); this.size += 1; } public void addToendofList (Object toAdd) // appends the end of the list // with a node { DNode temp = new DNode (toAdd, this.tail, this.tail.getPrev()); this.tail.getPrev().changeNext(temp); this.tail.changePrev(temp); this.size += 1; } public void insertAfterNode(DNode current, Object input)// Inserts a new // a new node after // current node { current.insertAfterNode(input); this.size += 1; } public int getSize() // returns the size of the list { return this.size; } public String toString() { String result = \"\"; for (DNode temp = this.head.getNext(); temp.hasNext(); temp = temp.getNext()) { result += temp.getValue(); result += \" -> \"; } result += \"End of list\"; return result; } } and code part2: public class DNode{ private Object e; // place holder for the type of object the //collection is storing private DNode next; // reference to the next node in the sequence // of.

1. I need help implementing a Stack with this java programming assignment:
Given a doubly linked list (code provided below) implement a Stack. You must use the doubly
link list class and utilize it as an object in your implementation of the stack.
A Stack is a Last in First Out (LiFO) structure which translates to the processes of outputting the
last element which was inputted in the collection. The Stack is based on the process of putting
things on top of one another and taking the item on top (think of a stack of papers).
Operations to implement:
push (E): Add an element to the start of the sequence
pop: Remove an element from the start of the sequence
Peek: Return the first element of the sequence without removing it
atIndex(x): Return the element at the given index (x) Or throw an exception if it is out of bound
(if you can control the user input then do that instead)
Size: Return the size of the Stack
isEmpty: Boolean, returns true if the Stack is empty
Empty: Empty the Stack
Code Part 1:
public class DoublyLinkedList{
private DNode head;
private DNode tail;
private int size;
public DoublyLinkedList(){ // construct an empty list
this.tail = new DNode (null, null, this.head);
this.head = new DNode (null, this.tail, null);
this.size = 0;
}
public DoublyLinkedList(DNode next){ // constructs a list
// out of a single node
this.tail = new DNode (null, null, next);
this.head = new DNode (null, next, null);
next.changeNext(this.tail);
next.changePrev(this.head);
this.size = 1;
}
public DoublyLinkedList(Object [] objectArray){ // construct a list out of

2. // an array
this.tail = new DNode (null, null, this.head);
this.head = new DNode (null, this.tail, null);
DNode temp = this.head;
for (Object e : objectArray)
{
//Anonomus function
new DNode (e, temp.getNext(),temp).insertBetweenNodes(temp, temp.getNext());
temp = temp.getNext();
this.size += 1;
}
}
public void addToFrontofList(Object toAdd){ // Appends the begining
// of the list
DNode temp = new DNode (toAdd, this.head.getNext(), this.head);
this.head.getNext().changePrev(temp);
this.head.changeNext(temp);
this.size += 1;
}
public void addToendofList (Object toAdd) // appends the end of the list
// with a node
{
DNode temp = new DNode (toAdd, this.tail, this.tail.getPrev());
this.tail.getPrev().changeNext(temp);
this.tail.changePrev(temp);
this.size += 1;
}
public void insertAfterNode(DNode current, Object input)// Inserts a new
// a new node after
// current node
{
current.insertAfterNode(input);
this.size += 1;
}
public int getSize() // returns the size of the list

3. {
return this.size;
}
public String toString()
{
String result = "";
for (DNode temp = this.head.getNext();
temp.hasNext(); temp = temp.getNext())
{
result += temp.getValue();
result += " -> ";
}
result += "End of list";
return result;
}
}
and code part2:
public class DNode{
private Object e; // place holder for the type of object the
//collection is storing
private DNode next; // reference to the next node in the sequence
// of nodes making up the linked list. Remember
// that even though Java passes Objects by value
// an object consisting of reference will behave
// the same as an object passed by reference unless
// a deep copy was made.
private DNode prev;
public DNode(Object e){ // Constructor for implementing a single node
this.e = e; // The value of the element to be assigned to
// this particular instance of node
this.next = null; // An empty reference since there is no node
// to follow.
this.prev = null;
}

4. public DNode(Object e, DNode next, DNode prev){ // Constructor for
//implementing a node that
//comes after another node
this.e = e; // The value of the element to be assigned to
// this particular instance of node
this.next = next; // reference to the subsequent node to follow
this.prev = prev;
}
public void changeNext(DNode next){ // Changes the link to the next node
this.next = next;
}
public void changePrev(DNode prev){ // Changes the link to the next node
this.prev = prev;
}
public DNode getNext(){ // Returns the node next in the sequence
return this.next;
}
public Object getValue(){ // Returns the value a node is holding
return this.e;
}
public Boolean hasNext(){ // Returns a boolean determining regarding
// the status of subsequent nodes after
// the current node
return !(this.next.getValue() == null || this.next == null);
}
public Boolean hasprev(){ // Returns a boolean determining regarding
// the status of subsequent nodes after
// the current node
return !(this.prev.getValue() == null || this.prev == null);
}
public void insertAfterNode( Object input){
this.changeNext(new DNode (input, this.getNext(), this));
}
public void insertAfterNode(DNode input){
this.changeNext(input);

5. input.changeNext(this.next);
input.changePrev(this);
}
public void insertbeforeNode(DNode input){
this.changeNext(input);
}
public void insertBetweenNodes(DNode before, DNode after){
this.changeNext(after);
this.changePrev(before);
before.changeNext(this);
after.changePrev(this);
}
public DNode getPrev(){
return this.prev;
}
}
Solution
Following is the program that contain functions like push,pop,isEmpty etc. call this function with
proper data.
import java.util.NoSuchElementException;
public class DoublyLinkedListImpl {
private Node head;
private Node tail;
private int size;
public DoublyLinkedListImpl() {
size = 0;
}
// this class keeps track all element info
private class Node {
E element;
Node next;

6. Node prev;
public Node(E element, Node next, Node prev) {
this.element = element;
this.next = next;
this.prev = prev;
}
}
// returns the size of the linked list
public int size() { return size; }
// return whether the list is empty or not
public boolean isEmpty() { return size == 0; }
// adds element at the starting of the linked list
public void push(E element) {
Node tmp = new Node(element, head, null);
if(head != null ) {head.prev = tmp;}
head = tmp;
if(tail == null) { tail = tmp;}
size++;
System.out.println("adding: "+element);
}
// this method removes element from the start of the linked list
public E pop() {
if (size == 0) throw new NoSuchElementException();
Node tmp = head;
head = head.next;
head.prev = null;
size--;
System.out.println("deleted: "+tmp.element);
return tmp.element;
}
public E Peek() {

7. if (isEmpty()) throw new NoSuchElementException("Stack underflow");
return head.element;
}
public void remove()
{
head = null;
}
// Takes index as argument and return data at index
public E GetNth(int index)
{
Node current = head;
int count = 0;
while (current != null)
{
if (count == index)
return current.element;
count++;
current = current.next;
}
assert(false);
return current.element;
}
public static void main(String a[]){
// Testing data to test the functions
DoublyLinkedListImpl dll = new DoublyLinkedListImpl();
dll.remove();
dll.push(10);
dll.push(34);
dll.size();
dll.Peek();
dll.GetNth(2);
dll.pop();
}
}