Question

-Fill in the reverse method below to return a new DoublyLinkedList consisting of the same elements in reverse order.

-The reverse method must not modify the original DoublyLinkedList.

-The reverse method must run in linear time.

Can someone answer this for me, please? In Java

public class DoublyLinkedList {

int size;

Node firstNode;

Node lastNode;

public DoublyLinkedList() {

size = 0;

firstNode = null;

lastNode = null;

}

// Problem 1 (15 pts)

// Fill in the method below to add a new node at the given index with the given element.

// If index is out of bounds, you must throw an IndexOutOfBoundsException.

// You must appropriately update all next and prev's.

// You must appropriately update the firstNode and lastNode.

// Hint: It's recommended that you use if statements to split into four or five different cases.

public void add(int index, E element) {

if(index < 0 || index > size) {

throw new IndexOutOfBoundsException();

}

Node adding = new Node(element, firstNode, lastNode);

if (size == 0) {

this.firstNode = adding;

this.lastNode = adding;

}

else if (index == 0) {

adding.next = firstNode;

firstNode.prev = adding;

firstNode = adding;

}

else if(index == size) {

adding.prev = lastNode;

lastNode.next = adding;

lastNode = adding;

}

else {

Node before = this.getNode(index - 1);

adding.next = before.next;

adding.prev = before;

before.next.prev = adding;

before.next = adding;

}

size++;

}

// Problem 2 (15 pts)

// Fill in the method below to remove a new node at the given index.

// If index is out of bounds, you must throw an IndexOutOfBoundsException.

// You must appropriately update all next and prev's.

// You must appropriately update the firstNode and lastNode.

// Hint: It's recommended that you use if statements to split into four or five different cases.

public E remove(int index) {

E toReturn = null;

if(index < 0 || index >=size) {

throw new IndexOutOfBoundsException();

}

if(size == 1) {

toReturn = firstNode.element;

firstNode = null;

lastNode= null;

} else if(index == 0) {

toReturn = firstNode.element;

firstNode = firstNode.next;

firstNode.prev = null;

} else if(index == size -1) {

toReturn = lastNode.element;

lastNode= lastNode.prev;

lastNode.next = null;

} else {

}

size--;

return toReturn;

}

// Problem 3 (10 pts)

// Fill in the getNode, getNodeFromFront, and getNodeFromBack methods below to return the node at the given index.

// The getNodeFromFront method starts from firstNode going forward.

// The getNodeFromBack method starts from the lastNode going backwards.

// The getNode method calls the getNodeFromFront method if index < size / 2 and it calls the getNodeFromBack method otherwise.

// If index is out of bounds, you must throw an IndexOutOfBoundsException.

public Node getNode(int index){

Node prevNode = null;

Node nextNode = firstNode;

while(index > 0){

prevNode = nextNode;

if(nextNode.next == null) {

throw new IndexOutOfBoundsException("Node index out of bounds");

}

nextNode = nextNode.next;

index--;

}

return nextNode;

}

private Node getNodeFromFront(int index) {

return this.getNode(index);

}

private Node getNodeFromBack(int index) {

return this.getNode(this.size() - index);

}

// Problem 4 (5 pts)

// Fill in the reverse method below to return a new DoublyLinkedList consisting of the same elements in reverse order.

// The reverse method must not modify the original DoublyLinkedList.

// The reverse method must run in linear time.

public DoublyLinkedList reverse(){

DoublyLinkedList newList = new DoublyLinkedList();

return null;

}

*Node Class*

public class Node<E> {

public E element;

public Node<E> prev;

public Node<E> next;

public Node(E element, Node<E> prev, Node<E> next) {

this.element = element;

this.prev = prev;

this.next = next;

}

}

Answer 1

Analyse the below code to reverse a double linked list . It doesn't effect the list and runs in a linear time.

    private TwoWayNode next() {

        if(head.next != null) return head.next;

        else return head.prev;

    }

        

        public void reverse()

        {

            if(head.next == null)

                return;

            TwoWayNode previous = head;

            TwoWayNode current = head.next;

            head.next = null;

            head.prev = current;

            while(current != null)

            {

                TwoWayNode next = current.next;

                current.next = previous;

                current.prev = next;

                previous = current;

                current = next;

            }

            //Switch head and tail.

        }