Added solutions for 2 linked list problems (#39)

Author: girishgr8

Java/convert-sorted-list-to-binary-search-tree.java

@@ -0,0 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode sortedArrayToBST(int[] nums) {
+        // use merge sort strategy to convert sorted list to BST 
+        return buildTree(0, nums.length-1, nums);
+    }
+    
+    public TreeNode buildTree(int l, int r, int nums[]){
+        // base case
+        if(l>r) return null;
+        // get mid of the whole index of the current list
+        int mid = (l+r)/2;
+        // create a node for mid of current subarray
+        TreeNode node = new TreeNode(nums[mid]);
+        // recurse for getting the left subtree
+        node.left = buildTree(l, mid-1, nums);
+        // recurse for getting the right subtree
+        node.right = buildTree(mid+1, r, nums);
+        // return the node
+        return node;
+    }
+    
+}

Java/remove-nth-node-from-end-of-list.java

@@ -0,0 +1,33 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        ListNode slow = head, fast = head, prev = null;
+        // move one ptr such that it points to nth node from start of Linked List
+        while(n-->1)
+            fast = fast.next;
+        
+        // now move the second ptr as long as first ptr doesn't point to last node
+        while(fast.next!=null){
+            prev = slow;
+            slow = slow.next;
+            fast = fast.next;
+        }
+        
+        // if the nth node from end is the start node of list
+        if(prev==null)
+            head = head.next;
+        else
+            prev.next = slow.next;
+        
+        return head;
+    }
+}