# Reverse doubly linked list [closed]

Are there any corner cases missing here?

class Node
{
int data;
Node next;
Node prev;
}

{

Node nextNode;

while(currentNode!=null)
{
nextNode = currentNode.next;

currentNode.next = previousNode;
currentNode.prev = nextNode;

previousNode = currentNode;
currentNode = nextNode;
}

}


## closed as off-topic by dfhwze, pacmaninbw, t3chb0t, Mast, VisualMelonSep 1 at 9:06

This question appears to be off-topic. The users who voted to close gave this specific reason:

• "Lacks concrete context: Code Review requires concrete code from a project, with sufficient context for reviewers to understand how that code is used. Pseudocode, stub code, hypothetical code, obfuscated code, and generic best practices are outside the scope of this site." – dfhwze, pacmaninbw, t3chb0t, VisualMelon
If this question can be reworded to fit the rules in the help center, please edit the question.

• Write unit tests and find out. – John Deters Oct 4 '16 at 3:16
• There is a (slightly) simpler approach. Each node in your doubly linked list has references to the previous and next nodes, so all you really have to do is travel to each node in the list and swap them. The only tricky part is that after the swap, you need to use the node's prev to get to what's (in your view) the next node. – Jerry Coffin Oct 4 '16 at 4:07
• This question lacks context how the nodes are linked. Is the list circular or not? – dfhwze Aug 31 at 10:20
• For us to be able to review this it would help to see the add node, insert node, delete node and the forward traverse methods as well as the reverse method. – pacmaninbw Aug 31 at 17:02

If we are allowed to pass the tail node to the reversal method (Node reverseDLL(Node head, Node tail)), we can perform the reversal by reversing the data integer fields instead of restructuring the list. All in all, I had this in mind:

import java.util.ArrayList;
import java.util.List;

class Node {
int data;
Node next;
Node prev;

Node(int data) {
this.data = data;
}
}

public class ReverseDLL {

static void reverseDLL2(Node head, Node tail) {
Node right = tail;

while (true) {
if (left == right) {
return;
}

int tmp = left.data;
left.data = right.data;
right.data = tmp;

if (left.next == right) {
return;
}

left = left.next;
right = right.prev;
}
}

for (Node current = head; current != null; current = current.next) {
System.out.print(current.data);
System.out.print(" ");
}
}

public static void main(String[] args) {
List<Node> nodes = new ArrayList<>();

for (int i = 0; i < 10; ++i) {
}

for (int i = 0; i < 9; ++i) {
nodes.get(i).next = nodes.get(i + 1);
}

for (int i = 1; i < 10; ++i) {
nodes.get(i).prev = nodes.get(i - 1);
}

printList(nodes.get(0));
reverseDLL2(nodes.get(0), nodes.get(9));
System.out.println();
printList(nodes.get(0));
reverseDLL2(null, null);
}
}


Hope that helps.

• This works fine if you have simple data types as the payload, but if you have more complex objects in there, depending on the case you may need to build a copy function, maybe end up using more memory and of course more code = higher chance of bugs. Also, it would be nice to check for circular lists. – ChatterOne Feb 1 '17 at 10:02
• @ChatterOne Not true. In Java, we deal with references to objects, and not objects themselves, so the reversal operation would be the same since we simply swap references. – coderodde Feb 1 '17 at 10:35
• You're right, I'm digging too much into Python these days, I guess – ChatterOne Feb 1 '17 at 12:44