Implement swap method that swaps two nodes x and y in a doubly linked list and reverse method that reverses a doubly linked list L in Java.

Thank you

package net.datastructures;

public class DoublyLinkedList {

//---------------- nested Node class ---------------- /** * Node of a doubly linked list, which stores a reference to its * element and to both the previous and next node in the list. */ private static class Node {

/** The element stored at this node */ private E element; // reference to the element stored at this node

/** A reference to the preceding node in the list */ private Node prev; // reference to the previous node in the list

/** A reference to the subsequent node in the list */ private Node next; // reference to the subsequent node in the list

/** * Creates a node with the given element and next node. * * @param e the element to be stored * @param p reference to a node that should precede the new node * @param n reference to a node that should follow the new node */ public Node(E e, Node p, Node n) { element = e; prev = p; next = n; }

// public accessor methods /** * Returns the element stored at the node. * @return the element stored at the node */ public E getElement() { return element; }

/** * Returns the node that precedes this one (or null if no such node). * @return the preceding node */ public Node getPrev() { return prev; }

/** * Returns the node that follows this one (or null if no such node). * @return the following node */ public Node getNext() { return next; }

// Update methods /** * Sets the node's previous reference to point to Node n. * @param p the node that should precede this one */ public void setPrev(Node p) { prev = p; }

/** * Sets the node's next reference to point to Node n. * @param n the node that should follow this one */ public void setNext(Node n) { next = n; } } //----------- end of nested Node class -----------

// instance variables of the DoublyLinkedList /** Sentinel node at the beginning of the list */ private Node header; // header sentinel

/** Sentinel node at the end of the list */ private Node trailer; // trailer sentinel

/** Number of elements in the list (not including sentinels) */ private int size = 0; // number of elements in the list

/** Constructs a new empty list. */ public DoublyLinkedList() { header = new Node<>(null, null, null); // create header trailer = new Node<>(null, header, null); // trailer is preceded by header header.setNext(trailer); // header is followed by trailer }

// public accessor methods /** * Returns the number of elements in the linked list. * @return number of elements in the linked list */ public int size() { return size; }

/** * Tests whether the linked list is empty. * @return true if the linked list is empty, false otherwise */ public boolean isEmpty() { return size == 0; }

/** * Returns (but does not remove) the first element of the list. * @return element at the front of the list (or null if empty) */ public E first() { if (isEmpty()) return null; return header.getNext().getElement(); // first element is beyond header }

/** * Returns (but does not remove) the last element of the list. * @return element at the end of the list (or null if empty) */ public E last() { if (isEmpty()) return null; return trailer.getPrev().getElement(); // last element is before trailer }

// public update methods /** * Adds an element to the front of the list. * @param e the new element to add */ public void addFirst(E e) { addBetween(e, header, header.getNext()); // place just after the header }

/** * Adds an element to the end of the list. * @param e the new element to add */ public void addLast(E e) { addBetween(e, trailer.getPrev(), trailer); // place just before the trailer }

/** * Removes and returns the first element of the list. * @return the removed element (or null if empty) */ public E removeFirst() { if (isEmpty()) return null; // nothing to remove return remove(header.getNext()); // first element is beyond header }

/** * Removes and returns the last element of the list. * @return the removed element (or null if empty) */ public E removeLast() { if (isEmpty()) return null; // nothing to remove return remove(trailer.getPrev()); // last element is before trailer }

// private update methods /** * Adds an element to the linked list in between the given nodes. * The given predecessor and successor should be neighboring each * other prior to the call. * * @param predecessor node just before the location where the new element is inserted * @param successor node just after the location where the new element is inserted */ private void addBetween(E e, Node predecessor, Node successor) { // create and link a new node Node newest = new Node<>(e, predecessor, successor); predecessor.setNext(newest); successor.setPrev(newest); size++; }

/** * Removes the given node from the list and returns its element. * @param node the node to be removed (must not be a sentinel) */ private E remove(Node node) { Node predecessor = node.getPrev(); Node successor = node.getNext(); predecessor.setNext(successor); successor.setPrev(predecessor); size--; return node.getElement(); }

/** * Produces a string representation of the contents of the list. * This exists for debugging purposes only. */ public String toString() { StringBuilder sb = new StringBuilder("("); Node walk = header.getNext(); while (walk != trailer) { sb.append(walk.getElement()); walk = walk.getNext(); if (walk != trailer) sb.append(", "); } sb.append(")"); return sb.toString(); } } //----------- end of DoublyLinkedList class -----------