diff --git a/02. Linked lists/hackerrank/reverse_double_list.java b/02. Linked lists/hackerrank/reverse_double_list.java
index 715f2b6..839e1b6 100644
--- a/02. Linked lists/hackerrank/reverse_double_list.java	
+++ b/02. Linked lists/hackerrank/reverse_double_list.java	
@@ -68,10 +68,10 @@ public class Solution {
     static DoublyLinkedListNode reverse(DoublyLinkedListNode head) {
 
         while (head != null) {
-            DoublyLinkedListNode temp = current.prev;
-            current.prev = current.next;
-            current.next = temp;
-            current = current.prev;
+            DoublyLinkedListNode temp = head.prev;
+            head.prev = head.next;
+            head.next = temp;
+            head = head.prev;
         }
         if(temp != null){
             head = temp.prev;
diff --git a/02. Linked lists/hackerrank/reverse_single_list.java b/02. Linked lists/hackerrank/reverse_single_list.java
new file mode 100644
index 0000000..2dabf84
--- /dev/null
+++ b/02. Linked lists/hackerrank/reverse_single_list.java	
@@ -0,0 +1,108 @@
+import java.io.*;
+import java.math.*;
+import java.security.*;
+import java.text.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.regex.*;
+
+public class Solution {
+
+    static class SinglyLinkedListNode {
+        public int data;
+        public SinglyLinkedListNode next;
+
+        public SinglyLinkedListNode(int nodeData) {
+            this.data = nodeData;
+            this.next = null;
+        }
+    }
+
+    static class SinglyLinkedList {
+        public SinglyLinkedListNode head;
+        public SinglyLinkedListNode tail;
+
+        public SinglyLinkedList() {
+            this.head = null;
+            this.tail = null;
+        }
+
+        public void insertNode(int nodeData) {
+            SinglyLinkedListNode node = new SinglyLinkedListNode(nodeData);
+
+            if (this.head == null) {
+                this.head = node;
+            } else {
+                this.tail.next = node;
+            }
+
+            this.tail = node;
+        }
+    }
+
+    public static void printSinglyLinkedList(SinglyLinkedListNode node, String sep, BufferedWriter bufferedWriter) throws IOException {
+        while (node != null) {
+            bufferedWriter.write(String.valueOf(node.data));
+
+            node = node.next;
+
+            if (node != null) {
+                bufferedWriter.write(sep);
+            }
+        }
+    }
+
+    // Complete the reverse function below.
+
+    /*
+     * For your reference:
+     *
+     * SinglyLinkedListNode {
+     *     int data;
+     *     SinglyLinkedListNode next;
+     * }
+     *
+     */
+    static SinglyLinkedListNode reverse(SinglyLinkedListNode head) {
+        SinglyLinkedListNode tail = null;
+        while (head != null) {
+            SinglyLinkedListNode next = head.next;
+            head.next = tail;
+            tail = head;
+            head = next;
+        }
+        return tail;
+    }
+
+    private static final Scanner scanner = new Scanner(System.in);
+
+    public static void main(String[] args) throws IOException {
+        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));
+
+        int tests = scanner.nextInt();
+        scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
+
+        for (int testsItr = 0; testsItr < tests; testsItr++) {
+            SinglyLinkedList llist = new SinglyLinkedList();
+
+            int llistCount = scanner.nextInt();
+            scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
+
+            for (int i = 0; i < llistCount; i++) {
+                int llistItem = scanner.nextInt();
+                scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
+
+                llist.insertNode(llistItem);
+            }
+
+            SinglyLinkedListNode llist1 = reverse(llist.head);
+
+            printSinglyLinkedList(llist1, " ", bufferedWriter);
+            bufferedWriter.newLine();
+        }
+
+        bufferedWriter.close();
+
+        scanner.close();
+    }
+}