[LeetCode] Reverse Linked List

Author: codehumane

src/main/java/linkedlist/LinkedListReverse.java

@@ -0,0 +1,31 @@
+package linkedlist;
+
+public class LinkedListReverse {
+
+    /**
+     * Reverse a singly linked list.
+     * <p>
+     * In this algorithm, each node will be moved exactly once.
+     * Therefore, the time complexity is O(N),
+     * where N is the length of the linked list.
+     * <p>
+     * We only use constant extra space so the space complexity is O(1).
+     */
+    public ListNode reverseList(ListNode head) {
+        ListNode reversed = null;
+        ListNode before = null;
+        ListNode cursor = head;
+        ListNode next;
+
+        while (cursor != null) {
+            next = cursor.next;
+            cursor.next = before;
+            reversed = cursor;
+            before = cursor;
+            cursor = next;
+        }
+
+        return reversed;
+    }
+
+}

src/test/java/linkedlist/LinkedListReverseTest.java

@@ -0,0 +1,34 @@
+package linkedlist;
+
+import lombok.val;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class LinkedListReverseTest {
+
+    @Test
+    public void reverseListExample1() {
+
+        // given: 1->2->3->4->5->NULL
+        val node1 = new ListNode(1);
+        val node2 = new ListNode(2);
+        val node3 = new ListNode(3);
+        val node4 = new ListNode(4);
+        val node5 = new ListNode(5);
+        node1.next = node2;
+        node2.next = node3;
+        node3.next = node4;
+        node4.next = node5;
+
+        // when
+        val reversed = new LinkedListReverse().reverseList(node1);
+
+        // then
+        assertEquals(node5, reversed);
+        assertEquals(node4, reversed.next);
+        assertEquals(node3, reversed.next.next);
+        assertEquals(node2, reversed.next.next.next);
+        assertEquals(node1, reversed.next.next.next.next);
+    }
+}