Update linkedlist algorithms

Author: sudheerj

README.md

@@ -109,27 +109,20 @@ 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/1.reverseSublist/reverseSublist.js)
+| No. | Name                             |                                                                                           Source                                                                                            | Playground                                                                                                                                                                                         |                                                                                      Documentation                                                                                       | Level  |                       Pattern                        |
+| :-: | :------------------------------- | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :----: | :--------------------------------------------------: |
+|  1  | Reverse sublist                  |                     [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/1.reverseSublist/reverseSublist.js)                     | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/1.reverseSublist/reverseSublist.js)            |                [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/1.reverseSublist/reverseSublist.js)                |  Easy  |                    List traversal                    |
+|  2  | Detect cycle in a linkedlist     |                         [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/2.detectLoop/detectLoop.js)                         | [Playground](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/2.detectLoop/detectLoop.js)                    |                    [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/2.detectLoop/detectLoop.js)                    |  Easy  | Floyd's cycle-finding or Tortoise and Hare algorithm |
+|  3  | Merge two sorted lists           |                [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/3.mergeTwoSortedLists/mergeTwoSortedLists.js)                | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/mergeTwoSortedLists.js)                        |           [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/3.mergeTwoSortedLists/mergeTwoSortedLists.md)           |  Easy  |                Arithmetic comparison                 |
+|  4  | Merge K sorted lists             |                  [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/4.mergeKSortedLists/mergeKSortedLists.js)                  | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/4.mergeKSortedLists/mergeKSortedLists.js)      |             [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/4.mergeKSortedLists/mergeKSortedLists.js)             |  Hard  |                  Divide and conquer                  |
+|  5  | Remove Kth node from end of list |               [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/5.removeKthNodeFromEnd/removeKthNodeFromEnd.js)               | [JavaScript](https://livecodes.io/?console&xhttps://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/5.removeKthNodeFromEnd/removeKthNodeFromEnd.js) |          [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/5.removeKthNodeFromEnd/removeKthNodeFromEnd.js)          | Medium |                     Two pointers                     |
+|  6  | Reorder list                     |        [Source](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/6.reorderList/reorderList.js)        | [Javascript](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/6.reorderList/reorderList.js)                                                  |                   [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/6.reorderList/reorderList.js)                   | Medium |                     Two pointers                     |
+|  7  | Find middle node                 |                     [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/7.findMiddleNode/findMiddleNode.js)                     | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/7.findMiddleNode/findMiddleNode.js)            |                [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/7.findMiddleNode/findMiddleNode.md)                |  Easy  |                     Two pointers                     |
+|  8  | Find Kth node from end of list   | [Source](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/8.findKthNodeFromEnd/findKthNodeFromEnd.js) | [JavaScript](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/8.findKthNodeFromEnd/findKthNodeFromEnd.js)                                    |            [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/8.findKthNodeFromEnd/findKthNodeFromEnd.md)            |  Easy  |                     Two pointers                     |
+|  9  | Partition list                   |      [Source](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/9.partitionList/partitionList.js)      | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/9.partitionList/partitionList.js)              | [Documentation](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/9.partitionList/partitionList.md) |  Medium      |      Two pointers                                                |
+| 10  | Remove duplicates                |                  [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/10.removeDuplicates/removeDuplicates.js)                   | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/10.removeDuplicates/removeDuplicates.js)       |             [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/10.removeDuplicates/removeDuplicates.md)              | Easy       |    Two pointers                                                  |
+| 11 |  Binary to decimal                                |  [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/11.binaryToDecimal/binaryToDecimal.js)                                                                                                                                                                                           |   [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/11.binaryToDecimal/binaryToDecimal.js)                                                                                                                                                                                                       |  [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/11.binaryToDecimal/binaryToDecimal.md)                                                                                                                                                                                          |  Easy      |    List traversal and math operations                                                  |
 
-   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)
-
-   3. Merge two sorted lists: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/mergeTwoSortedLists.js)
-
-   4. Merge K sorted lists: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/mergeKSortedLists.js)
-   
-   5. Remove Nth node from end of list: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/removeKthNodeFromEnd.js)
-
-   6. Reorder list: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/reorderList.js)
-
-   7. Find middle node: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/findMiddleNode.js)
-
-   8. Find Kth node from end of list: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/findKthNodeFromEnd.js)
-
-   9. Partition list: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/partitionList.js)
-
-   10. Remove duplicates: [JavaScript](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/removeDuplicates.js)
-
-   11. Binary to decimal: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/linkedlist/binaryToDecimal.js)
 
 
 ### Doubly linkedlist

src/images/binary-to-decimal.png

@@ -5,7 +5,7 @@ public class Node {
     public Node next;
     public int value;
 
-    Node(int value) {
+    public Node(int value) {
         this.value = value;
         this.next = null;
     }

src/images/find-middle-node.png

@@ -0,0 +1,55 @@
+package java1.algorithms.linkedlist.binaryToDecimal;
+
+import java1.algorithms.linkedlist.Node;
+
+public class BinaryToDecimal {
+    private static int binaryToDecimal(Node head, int length){
+        Node current = head;
+        int decimal = 0;
+
+        for (int i= length-1; i>=0; i--) {
+            decimal += Math.pow(2, i) * current.value;
+            current = current.next;
+        }
+
+        return decimal;
+    }
+
+    private static int binaryToDecimalDoubling(Node head){
+        Node current = head;
+        int decimal = 0;
+
+        while(current != null) {
+            decimal = decimal * 2 + current.value;
+            current = current.next;
+        }
+
+        return decimal;
+    }
+
+    public static void main(String[] args) {
+        Node headNode1 = new Node(1);
+        Node node1 = new Node(0);
+        Node node2 = new Node(0);
+        Node node3 = new Node(1);
+
+        headNode1.setNext(node1);
+        node1.setNext(node2);
+        node2.setNext(node3);
+
+        Node headNode2 = new Node(1);
+        Node node4 = new Node(0);
+        Node node5 = new Node(1);
+        Node node6 = new Node(1);
+
+        headNode2.setNext(node4);
+        node4.setNext(node5);
+        node5.setNext(node6);
+
+        System.out.println(binaryToDecimalDoubling(headNode1));
+        System.out.println(binaryToDecimalDoubling(headNode2));
+
+        System.out.println(binaryToDecimal(headNode1, 4));
+        System.out.println(binaryToDecimal(headNode2, 4));
+    }
+}

src/images/kth-node-from-end.png

@@ -0,0 +1,39 @@
+**Problem statement:**
+Given a `head` of singly linked list. The linked list holds the binary representation of a decimal number using either 0 or 1 digit. Calculate the decimal value of the linked list and return the number.
+
+**Note:** The MSB(Most Significant Bit) is situated at the head of linkedlist.
+
+## Examples:
+Example 1:
+
+Input: [1,0,0,1]
+Output: 9
+
+Example 2:
+
+Input: [1,0,1,1]
+Output: 11
+
+## Pictorial representation
+
+ ![Screenshot](../../../../images/binary-to-decimal.png)
+
+**Algorithmic Steps**
+This problem is solved with the help of linked list iteration and mathematic calculations. The algorithmic approach can be summarized as follows: 
+   
+1. Create a current node(`current`) to traverse the list. It is initialized with head node.
+
+2. Create a decimal variable(`decimal`) to store the decimal equivalent and initialized to zero. 
+   
+3. Loop over the list until the current pointer is not null. The loop starts from left to right.
+
+4. In each iteration, update the decimal value by adding the previous decimal value and the product of power of 2 with current binary digit.
+   
+5. Update the current node to its next element for each iteration.
+   
+6. Return the decimal value as equivalent binary number.
+
+**Time and Space complexity:**
+This algorithm takes a time complexity of `O(n)`, where `n` is the number of nodes in the list. This is because we needs to traverse at most once to calculate the decimal equivalent.
+
+Here, we don't use any additional datastructure other than one pointer variable. Hence, the space complexity will be `O(1)`.