add more solutions

Author: chihungyu1116

124 Binary Tree Maximum Path Sum.js

@@ -1,3 +1,16 @@
+// Given a binary tree, find the maximum path sum.
+
+// For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path does not need to go through the root.
+
+// For example:
+// Given the below binary tree,
+
+//        1
+//       / \
+//      2   3
+// Return 6.
+
+
 // http://bangbingsyb.blogspot.com/2014/11/leetcode-binary-tree-maximum-path-sum.html
 /**
  * Definition for a binary tree node.
@@ -22,13 +35,17 @@ var maxPathSum = function(root) {
 
         var leftVal = Math.max(findMaxPath(node.left), 0);
         var rightVal = Math.max(findMaxPath(node.right), 0);
-    
+        
         var ps1 = node.val + Math.max(leftVal, rightVal);
         // ps2 means taking this current node as parent node and stop there
         var ps2 = node.val + leftVal + rightVal;
 
+        // maxVal as if we end counting value here, what will be the maximum val
+        // leftVal and rightVal can be negative values
         maxVal = Math.max(maxVal, Math.max(ps1, ps2));
+
         // return ps1 only since, ps2 cannot be combined with the parent node
+        // leftVal and rightVal can be negative values, however, we can to see if combining with values down below can give higher number
         return ps1;
     }
 };

224 Basic Calculator.js

@@ -0,0 +1,53 @@
+/**
+Implement a basic calculator to evaluate a simple expression string.
+
+The expression string may contain open ( and closing parentheses ), the plus + or minus sign -, non-negative integers and empty spaces .
+
+You may assume that the given expression is always valid.
+
+Some examples:
+"1 + 1" = 2
+" 2-1 + 2 " = 3
+"(1+(4+5+2)-3)+(6+8)" = 23
+Note: Do not use the eval built-in library function.
+*/
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var calculate = function(s) {
+    var stack = [],
+        len = s.length,
+        sum = 0,
+        num,
+        ch,
+        j,
+        i;
+    
+    stack.push(1);
+    stack.push(1);
+    
+    for (i = 0; i < len; i++) {
+        ch = s.charAt(i);
+        
+        if (!isNaN(parseInt(ch))) {
+            num = parseInt(ch);
+            
+            for (j = i + 1; j < len && !isNaN(parseInt(s.charAt(j))); j++) {
+                num = num * 10 + parseInt(s.charAt(j));
+            }
+            
+            sum += stack.pop() * num;
+            
+            i = j - 1;
+        } else if (ch === '+' || ch === '(') {
+            stack.push(stack[stack.length - 1]);
+        } else if (ch === '-') {
+            stack.push(stack[stack.length - 1] * (-1));
+        } else if (ch === ')') {
+            stack.pop();
+        }
+    }
+    
+    return sum;
+};

23 Merge k Sorted Lists.js

@@ -0,0 +1,60 @@
+// Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
+// http://www.cnblogs.com/springfor/p/3869217.html
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode[]} lists
+ * @return {ListNode}
+ */
+var mergeKLists = function(lists) {
+    return mergeHelper(lists, 0, lists.length - 1);
+};
+
+function mergeHelper(lists, l, r) {
+    if(l === r) {
+        return lists[l];
+    }
+    
+    if(l > r) {
+        return null;
+    }
+    
+    var mid = Math.floor((l + r)/2);
+    var left = mergeHelper(lists, l, mid);
+    var right = mergeHelper(lists, mid + 1, r);
+    
+    return mergeTwoLists(left, right);
+}
+
+
+function mergeTwoLists(l1, l2) {
+    var dummy = new ListNode(0);
+    var cur = dummy;
+    
+    while(l1 && l2) {
+        if(l1.val < l2.val) {
+            cur.next = l1;
+            l1 = l1.next;
+        } else {
+            cur.next = l2;
+            l2 = l2.next;
+        }
+        
+        cur = cur.next;
+    }
+    
+    if(l1) {
+        cur.next = l1;
+    }
+    
+    if(l2) {
+        cur.next = l2;
+    }
+    
+    return dummy.next;
+}

239 Sliding Window Maximum.js

@@ -0,0 +1,56 @@
+// Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.
+
+// For example,
+// Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.
+
+// Window position                Max
+// ---------------               -----
+// [1  3  -1] -3  5  3  6  7       3
+//  1 [3  -1  -3] 5  3  6  7       3
+//  1  3 [-1  -3  5] 3  6  7       5
+//  1  3  -1 [-3  5  3] 6  7       5
+//  1  3  -1  -3 [5  3  6] 7       6
+//  1  3  -1  -3  5 [3  6  7]      7
+// Therefore, return the max sliding window as [3,3,5,5,6,7].
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var maxSlidingWindow = function(nums, k) {
+    var result = [],
+        linkedListWithTwoEndsOps = [],
+        len = nums.length,
+        i;
+    
+    if (k > len || k === 0) {
+        return result;
+    }
+    
+    for (i = 0; i < len; i++) {
+        // Remove anything that is less than the current value
+        // so linkedListWithTwoEndsOps maintains values greater than the curret value
+        while (linkedListWithTwoEndsOps.length > 0 && nums[linkedListWithTwoEndsOps[linkedListWithTwoEndsOps.length - 1]] < nums[i]) {
+            var val = linkedListWithTwoEndsOps.pop();
+        }
+        
+        // In case that all elements in the linkedListWithTwoEndsOps are all greater than the current one (descending order)
+        // Shift out the 
+        if (linkedListWithTwoEndsOps[0] < i - k + 1) {
+            linkedListWithTwoEndsOps.shift();
+        }
+        
+        linkedListWithTwoEndsOps.push(i);
+        
+        // For each sliding window movement, we record the highest value in that sliding window
+        // i >= k - 1 to ensure that we don't prematurely record values before we get to the full range of the first sliding window
+        // e.g. [1  3  -1] -3  5  3  6  7       3
+        // this ensure that i is at least at -1 (index 2)
+        if (i >= k - 1) {
+            result.push(nums[linkedListWithTwoEndsOps[0]]);
+        }
+    }
+    
+    return result;
+};

242 Valid Anagram.js

@@ -1,31 +1,41 @@
-// Leetcode #242 
-// Language: Javascript
-// Problem: https://leetcode.com/problems/valid-anagram/
-// Author: Chihung Yu
+// Given two strings s and t, write a function to determine if t is an anagram of s.
+
+// For example,
+// s = "anagram", t = "nagaram", return true.
+// s = "rat", t = "car", return false.
+
+
+
 /**
  * @param {string} s
  * @param {string} t
  * @return {boolean}
  */
 var isAnagram = function(s, t) {
-    if((s === null || t === null) || (s.length !== t.length)){
-        return false;
-    }
-    
-    var hash = {};
-    
-    for(var i = 0; i < s.length; i++){
-        hash[s[i]] = hash[s[i]] || 0;
-        hash[s[i]]++;
-    }
-    
-    for(var j = 0; j < t.length; j++){
-        if(!hash[t[j]]){
-            return false;
-        }
-        
-        hash[t[j]]--;
-    }
-    
-    return true;
+   var slen = s.length;
+   var tlen = t.length;
+   
+   if(slen !== tlen) {
+       return false;
+   }
+   
+   var hash = {};
+   
+   for(var i = 0; i < slen; i++) {
+       var char = s[i];
+       hash[char] = hash[char] || 0;
+       hash[char]++;
+   }
+   
+   for(i = 0; i < tlen; i++) {
+       char = t[i];
+       
+       if(hash[char] === undefined || hash[char] === 0) {
+           return false;
+       }
+       
+       hash[char]--;
+   }
+   
+   return true;
 };

25 Reverse Nodes in k-Group.js

@@ -0,0 +1,64 @@
+
+// Given a linked list, reverse the nodes of a linked list k at a time and return its modified list.
+
+// If the number of nodes is not a multiple of k then left-out nodes in the end should remain as it is.
+
+// You may not alter the values in the nodes, only nodes itself may be changed.
+
+// Only constant memory is allowed.
+
+// For example,
+// Given this linked list: 1->2->3->4->5
+
+// For k = 2, you should return: 2->1->4->3->5
+
+// For k = 3, you should return: 3->2->1->4->5
+
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+
+ // http://www.geeksforgeeks.org/reverse-a-list-in-groups-of-given-size/
+var reverseKGroup = function(head, k) {
+    var cur = head;
+    var pre = null;
+    var post = null;
+    var count = 0;
+    
+    while(cur !== null && count < k) {
+        cur = cur.next;
+        count++;   
+    }
+    
+    if(count !== k) {
+        return head;
+    }
+    
+    cur = head;
+
+    while(cur !== null && count > 0) {
+        post = cur.next;
+        cur.next = pre;
+        pre = cur;
+        cur = post;
+        count--;
+    }
+    
+    // post is now a pointer to (k+1)th node
+    // recursively call for the list starting from cur
+    if(post !== null) {
+        head.next = reverseKGroup(post, k);
+    }
+    
+    return pre;
+};