add more

Author: Chihung Yu

148 Sort List.js

@@ -0,0 +1,75 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+ 
+var sortList = function(head) {
+    if(head === null) {
+        return null;
+    }
+    
+    var len = 0;
+    var p = head;
+    
+    while(p) {
+        len++;
+        p = p.next;
+    }
+    
+    var newHead = sort(len);
+    
+    return newHead;
+    
+    function sort(len) {
+        if(len === 1) {
+            var temp = head;
+            head = head.next;
+            temp.next = null;
+            return temp;
+        }
+        
+        var leftHead = sort(parseInt(len/2));
+        var rightHead = sort(len - parseInt(len/2));
+        var newHead = merge(leftHead, rightHead);
+        
+        return newHead;
+    }
+    
+    function merge(first, second) {
+        var h = new ListNode(-1);
+        var cur = h;
+    
+        while(first && second) {
+            
+            
+            if(first.val <= second.val) {
+                cur.next = first;
+                first = first.next;
+            } else {
+                cur.next = second;
+                second = second.next;
+            }
+            
+            cur = cur.next;
+        }
+        
+        if(first) {
+            cur.next = first;
+        }
+        
+        if(second) {
+            cur.next = second;
+        }
+        
+        cur = h.next;
+        h.next = null;
+        return cur;
+    }
+};

219 Contains Duplicate II.js

@@ -34,4 +34,6 @@ var containsNearbyDuplicate = function(nums, k) {
     }
 
     return false;
-};
+};
+
+

220 Contains Duplicate III.js

@@ -0,0 +1,50 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} t
+ * @return {boolean}
+ */
+
+var search = function(pairs, t, k) {
+    var p1 = 0;
+    
+    while(p1 < pairs.length) {
+        var p2 = p1 + 1;
+        
+        while(p2 < pairs.length) {
+            if(Math.abs(pairs[p1][0] - pairs[p2][0]) <= t && Math.abs(pairs[p1][1] - pairs[p2][1]) <= k) {
+                return true;
+            } else {
+                if(Math.abs(pairs[p1][0] - pairs[p2][0]) > t) {
+                    break;
+                } else {
+                    p2++;   
+                }
+            }
+        }
+        
+        p1++;
+    }
+    
+    return false;
+}
+
+var containsNearbyAlmostDuplicate = function(nums, k, t) {
+    if(k <= 0) {
+        return false;
+    }
+    
+    if(nums === null || nums.length === 0) {
+        return false;
+    }
+    
+    var pairs = [];
+    
+    for(var i = 0; i < nums.length; i++){
+        pairs.push([nums[i], i]);
+    }
+
+    pairs.sort(function(a,b){return a[0] > b[0] ? 1 : -1;});
+
+    return search(pairs, t, k);
+};