Add reverse linkedlist based on range

Author: sudheerj

README.md

@@ -109,7 +109,7 @@ List of Programs related to data structures and algorithms
 
 ### LinkedList
 
-   1. Reverse substring: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/reverseSubstring.js)
+   1. Reverse substring: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/1.reverseSublist/reverseSublist.js)
 
    2. Detect cycle in a linkedlist: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/detectLoop.js)
 

src/java1/algorithms/linkedlist/reverseSublist/ReverseSublist.java

@@ -0,0 +1,91 @@
+package java1.algorithms.linkedlist.reverseSublist;
+
+class Node {
+    public int value;
+    public Node next;
+
+    Node(int value) {
+        this.value = value;
+        this.next = null;
+    }
+}
+
+public class ReverseSublist {
+    private Node head;
+    private Node tail;
+    private int length;
+
+    ReverseSublist() {
+        head = null;
+        tail = null;
+        length = 0;
+    }
+
+    public void append(int value) {
+        Node newNode = new Node(value);
+        if(head == null) {
+            head = newNode;
+            tail = newNode;
+        } else {
+            newNode.next = tail;
+            tail = newNode;
+        }
+
+        length++;
+    }
+
+    public Node reverseBetween(int left, int right) {
+        if(head == null || head.next == null || left == right) return head;
+
+        Node dummy = new Node(0);
+        dummy.next = head;
+
+        Node leftPrev = dummy;
+        Node current = head;
+
+        for (int i = 0; i < left-1; i++) {
+            leftPrev = current;
+            current = current.next;
+        }
+
+        Node prev = null;
+
+        for (int i = 0; i < right-left+1; i++) {
+            Node temp = current.next;
+            current.next = prev;
+            prev = current;
+            current = temp;
+        }
+
+        leftPrev.next.next = current;
+        leftPrev.next = prev;
+
+        head = dummy.next;
+
+        return head;
+    }
+
+    public void printList() {
+        Node temp = head;
+        while(temp != null) {
+            System.out.println(temp.value);
+            temp = temp.next;
+        }
+    }
+
+    public static void main(String[] args) {
+        ReverseSublist myReverseSublist = new ReverseSublist();
+        myReverseSublist.append(1);
+        myReverseSublist.append(2);
+        myReverseSublist.append(3);
+        myReverseSublist.append(4);
+        myReverseSublist.append(5);
+        myReverseSublist.append(6);
+
+        myReverseSublist.reverseBetween(2, 5);
+
+        myReverseSublist.printList();
+    }
+}
+
+

src/java1/algorithms/linkedlist/reverseSublist/ReverseSublist.md

@@ -0,0 +1,46 @@
+**Problem statement:**
+Given the `head` of a singly linked list and two integers `left` and `right` where left <= right. Reverse the nodes of the list that fall between the positions `left` and `right` (inclusive), and return the reversed list.
+
+**Note:** The positions are 1-indexed(not 0-indexed). i.e, 1 <= left <= right <= n. Where `n` is the length of list.
+
+
+## Examples:
+Example 1:
+
+Input: head = [1,2,3,4,5,6], left=2, right=5
+Output: [1,5,4,3,2,6]
+
+Example 2:
+
+Input: head = [1,2,3,4,5,6], left=1, right=3
+Output: [3,2,1,4,5,6]
+
+Example 3: 
+
+Input: head = [4], left=1, right=1
+Output: [4]
+
+**Algorithmic Steps**
+This problem is solved by understanding the concept of full reversal of linkedlist and keeping the pointers for the nodes at the boundaries where we actually reverse the sublist. Later, these boundary pointers are helpful to connect the reversed list with the remaining parts of the non-reversed linkedlist. The algorithmic approach can be summarized as follows: 
+
+1. Handle the base case scenarios such as empty list ,or list with one node, or left and right pointers are equal. In these cases, there is no need of reversal of linkedlist.(i.e, Just return the original list)
+
+2. Create a dummy node(`dummy`) to simplify the edge case handling, such as when reversing the list from the first node itself.
+
+3. Connect the dummy node to the head node.
+
+4. Declare the boundary pointers `leftPrev` and `current` pointing to the dummy node and head nodes respectively. These pointers are helpful to point the node before the reversal and beginning of the reversal list respectively.
+
+5. Iterate the loop `left-1` times to reach the boundary section.
+
+6. Implement the reversal of sublist starting from `current` node and keep tracking the previous node `prev` initialized with `null`. This reversal logic needs to be looped `right-left+1` times.
+
+7. Upon reversing the references of sublist, connect the non-reversed sublists with reversed section.
+
+8. At last, return the head node(`this.dummy.next`) which contains the reversed nodes of linkedlist.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of nodes in a linkedlist. This is because we are traversing the list at most once. 
+
+Here, we don't use any additional datastructure other than few pointers for the node. Hence, the space complexity will be `O(1)`.

src/javascript/algorithms/linkedlist/reverseSubstring.js src/javascript/algorithms/linkedlist/1.reverseSublist/reverseSublist.js

@@ -6,12 +6,10 @@ class Node {
 }
 
 class LinkedList {
-    constructor(value) {
-        const newNode = new Node(value);
-        this.head = newNode;
-        this.head = newNode;
-        this.tail = newNode;
-        this.length = 1;
+    constructor() {
+        this.head = null;
+        this.tail = null;
+        this.length = 0;
     }
 
     push(value) {
@@ -27,29 +25,62 @@ class LinkedList {
         return this;
     }
 
-    reverseBetween(m, n) {
+    reverseBetween1(left, right) {
+        if(!this.head || this.head.next !== null || left === right) return this.head;
+
+        let dummy = new Node(0);
+        dummy.next = this.head;
+
+        let leftPrev = dummy;
+        let current = this.head;
+
+        for (let i = 0; i < left-1; i++) {
+           leftPrev = current;
+           current = current.next;
+        }
+
+        let prev = null;
+        for (let i = 0; i < right-left+1; i++) {
+            let temp = current.next;
+            current.next = prev;
+            prev = current;
+            current = temp;
+        }
+
+        leftPrev.next.next = current;
+        leftPrev.next = prev;
+
+        this.head = dummy.next;
+
+        return this.head;
+    }
+
+    reverseBetween2(left, right) {
         if (this.head === null) return;
 
         const dummy = new Node(0);
         dummy.next = this.head;
         let prev = dummy;
 
-        for (let i = 0; i < m; i++) {
+        for (let i = 0; i < left-1; i++) {
             prev = prev.next;
         }
 
         let current = prev.next;
-        for (let i = 0; i < n - m; i++) {
+        for (let i = 0; i < right - left; i++) {
             const temp = current.next;
             current.next = temp.next;
             temp.next = prev.next;
             prev.next = temp;
         }
 
         this.head = dummy.next;
+
+        return this.head;
     }
 
-    reverseBetweenUsingReverseList(m, n) {
+    //UsingReverseList
+    reverseBetween3(left, right) {
         if(!this.head) return;
 
         let current = this.head;
@@ -59,14 +90,14 @@ class LinkedList {
         let revEndNext = null;
         let i = 0;
 
-        while(current && i <= n) {
-            if(i < m) {
+        while(current && i <= right) {
+            if(i < left) {
                 revPrev = current;
             }
-            if(i === m) {
+            if(i === left) {
                 revBegin = current;
             }
-            if(i === n) {
+            if(i === right) {
                 revEnd = current;
                 revEndNext = current.next;
             }
@@ -100,12 +131,19 @@ class LinkedList {
 
 }
 
-const myLinkedList = new LinkedList(1);
+const myLinkedList = new LinkedList();
+myLinkedList.push(1);
 myLinkedList.push(2);
 myLinkedList.push(3);
 myLinkedList.push(4);
 myLinkedList.push(5);
+myLinkedList.push(6);
+
+const myLinkedList1 = new LinkedList();
+myLinkedList1.push(4);
 
-myLinkedList.reverseBetween(2, 4);
-myLinkedList.reverseBetweenUsingReverseList(1, 3);
+console.dir(myLinkedList.reverseBetween1(2, 5), {depth: null});
+console.dir(myLinkedList.reverseBetween2(2, 5), {depth: null});
+console.dir(myLinkedList.reverseBetween3(1, 3), {depth: null});
+console.dir(myLinkedList1.reverseBetween1(1, 1));
 

src/javascript/algorithms/linkedlist/1.reverseSublist/reverseSublist.md

@@ -0,0 +1,46 @@
+**Problem statement:**
+Given the `head` of a singly linked list and two integers `left` and `right` where left <= right. Reverse the nodes of the list that fall between the positions `left` and `right` (inclusive), and return the reversed list.
+
+**Note:** The positions are 1-indexed(not 0-indexed). i.e, 1 <= left <= right <= n. Where `n` is the length of list.
+
+
+## Examples:
+Example 1:
+
+Input: head = [1,2,3,4,5,6], left=2, right=5
+Output: [1,5,4,3,2,6]
+
+Example 2:
+
+Input: head = [1,2,3,4,5,6], left=1, right=3
+Output: [3,2,1,4,5,6]
+
+Example 3: 
+
+Input: head = [4], left=1, right=1
+Output: [4]
+
+**Algorithmic Steps**
+This problem is solved by understanding the concept of full reversal of linkedlist and keeping the pointers for the nodes at the boundaries where we actually reverse the sublist. Later, these boundary pointers are helpful to connect the reversed list with the remaining parts of the non-reversed linkedlist. The algorithmic approach can be summarized as follows: 
+
+1. Handle the base case scenarios such as empty list ,or list with one node, or left and right pointers are equal. In these cases, there is no need of reversal of linkedlist.(i.e, Just return the original list)
+
+2. Create a dummy node(`dummy`) to simplify the edge case handling, such as when reversing the list from the first node itself.
+
+3. Connect the dummy node to the head node.
+
+4. Declare the boundary pointers `leftPrev` and `current` pointing to the dummy node and head nodes respectively. These pointers are helpful to point the node before the reversal and beginning of the reversal list respectively.
+
+5. Iterate the loop `left-1` times to reach the boundary section.
+
+6. Implement the reversal of sublist starting from `current` node and keep tracking the previous node `prev` initialized with `null`. This reversal logic needs to be looped `right-left+1` times.
+
+7. Upon reversing the references of sublist, connect the non-reversed sublists with reversed section.
+
+8. At last, return the head node(`this.dummy.next`) which contains the reversed nodes of linkedlist.
+
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of nodes in a linkedlist. This is because we are traversing the list at most once. 
+
+Here, we don't use any additional datastructure other than few pointers for the node. Hence, the space complexity will be `O(1)`.

src/javascript/datastructures/singlyLinkedList/singlyLinkedList.js

@@ -113,7 +113,7 @@ class LinkedList {
   }
 
   reverse() {
-    if(length == 0) return undefined;
+    if(this.length === 0) return undefined;
 
     let temp = this.head;
     this.head = this.tail;
@@ -131,6 +131,7 @@ class LinkedList {
 }
 
 const myLinkedList = new LinkedList();
+console.log(myLinkedList.push(1));
 console.log(myLinkedList.push(2));
 console.log(myLinkedList.push(3));