add read me

Author: Chihung Yu

103 Binary Tree Zigzag Level Order Traversal.js

@@ -0,0 +1,56 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+var zigzagLevelOrder = function(root) {
+    var result = []
+    
+    if(!root) {
+        return result;
+    }
+    
+    var fromLeft = false;
+    var curLvl = [];
+    curLvl.push(root);
+
+    var nextLvl = [];
+    var temp = [];
+
+    while(curLvl.length !== 0) {
+        var p = curLvl.pop();
+        temp.push(p.val);
+        
+        if(fromLeft) {
+            if(p.left) {
+                nextLvl.push(p.left);
+            }
+            if(p.right) {
+                nextLvl.push(p.right);
+            }
+        } else {
+            if(p.right) {
+                nextLvl.push(p.right);
+            }
+            if(p.left) {
+                nextLvl.push(p.left);
+            }
+        }
+        
+        if(curLvl.length === 0) {
+            fromLeft = !fromLeft;
+            result.push(temp);
+            temp = [];
+            curLvl = nextLvl;
+            nextLvl = [];
+        }
+    }
+    
+    return result
+};

105 Construct Binary Tree from Preorder and Inorder Traversal.js

@@ -0,0 +1,53 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number[]} preorder
+ * @param {number[]} inorder
+ * @return {TreeNode}
+ */
+var buildTree = function(preorder, inorder) {
+    if(!preorder || !inorder) {
+        return null;
+    }
+    
+    if(preorder.length !== inorder.length) {
+        return null;
+    }
+    
+    return generate(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
+};
+
+
+var generate = function(preorder, pl, pr, inorder, il, ir) {
+    if(pl > pr || il > ir) {
+        return null
+    }
+    
+    
+    var root = new TreeNode(preorder[pl]);
+    var midIndex = -1;
+    
+    for(var i = 0; i < inorder.length; i++) {
+        if(inorder[i] === preorder[pl]) {
+            midIndex = i;
+            break;
+        }
+    }
+    
+    if(midIndex === -1) {
+        return null;
+    }
+    
+    var left = generate(preorder, pl + 1, pl + (midIndex - il), inorder, il, midIndex - 1);
+    var right = generate(preorder, pl + (midIndex - il) + 1, pr, inorder, midIndex + 1, ir);
+    
+    root.left = left;
+    root.right = right;
+    
+    return root;
+}

131 Palindrome Partitioning.js

@@ -1,55 +1,42 @@
-// Leetcode 131
-// Language: Javascript
-// Problem: https://leetcode.com/problems/palindrome-partitioning/
-// Author: Chihung Yu
 /**
  * @param {string} s
- * @returns {string[][]}
+ * @return {string[][]}
  */
 var partition = function(s) {
-    
     var result = [];
-    var list = [];
 
-    if(s === null || s.length === 0){
-        return [];
-    }
+    generate(s, 0, [], result);
 
-    calculate(s, result, list);
     return result;
 };
 
-var isPalindrome = function(s){
-    var i = 0;
-    var j = s.length - 1;
+var generate = function(s, index, output, result) {
+    if(index === s.length){
+        result.push(output.slice());
+        return;
+    }
 
-    while(i < j){
-        if(s[i] !== s[j]){
-            return false;
-        }
+    
+    for(var i = index; i < s.length; i++) {
+        var str = s.substring(index, i);
 
-        i++;
-        j--;
+        if(isPalindrome(s, index, i)){
+            output.push(s.substring(index, i + 1));
+            generate(s, i + 1, output, result);
+            output.pop();
+        }
     }
-    
-    return true;
 }
 
-var calculate = function(s, result, list){
-    if(s.length === 0){
-        result.push(list.slice());
-        return;
-    }
-    
-    for(var i = 1; i <= s.length; i++){
-        var substring = s.substring(0,i);
-        
-        if(isPalindrome(substring)){
-            list.push(substring);
-            var restSubstring = s.substring(i);
-            
-            calculate(restSubstring, result, list);
-            list.pop();
+var isPalindrome = function(s, head, tail) {
+    while(head < tail) {
+        if(s[head] !== s[tail]) {
+            return false;
         }
+        
+        head++;
+        tail--;
     }
+    
+    return true;
 }

200 Number of Islands.js

@@ -0,0 +1,51 @@
+/**
+ * @param {character[][]} grid
+ * @return {number}
+ */
+var numIslands = function(grid) {
+    var count = 0;
+    
+    var rows = grid.length;
+    
+    if(rows === 0){
+        return count;
+    }
+    
+    var cols = grid[0].length;
+    
+    if(cols === 0) {
+        return count;
+    }
+    
+    for(i = 0; i < rows; i++) {
+        for(var j = 0; j < cols; j++) {
+            if(grid[i][j] === "1") {
+                count++;
+                 walk(grid, i, j, rows, cols);
+            }
+        }
+    }
+    return count;
+};
+
+var walk = function(grid, x, y, rows, cols) {
+    if(grid[x][y] === "1") {
+        grid[x][y] = "0";    
+    }
+
+    if((x + 1) < rows && grid[x+1][y] === "1") {
+        walk(grid, x + 1, y, rows, cols);    
+    }
+    
+    if((x - 1) >= 0 && grid[x-1][y] === "1") {
+        walk(grid, x - 1, y, rows, cols);    
+    }
+    
+    if((y + 1) < cols && grid[x][y+1] === "1") {
+        walk(grid, x, y + 1, rows, cols);    
+    }
+    
+    if((y - 1) >= 0 && grid[x][y-1] === "1") {
+        walk(grid, x, y - 1, rows, cols);    
+    }
+}

209 Minimum Size Subarray Sum.js

@@ -0,0 +1,30 @@
+// http://blog.csdn.net/lisonglisonglisong/article/details/45666975
+
+/**
+ * @param {number} s
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minSubArrayLen = function(s, nums) {
+    var sum = 0;
+    var left = 0;
+    var right = -1;
+    var len = nums.length;
+    var minLen = Infinity;
+    
+    while(right < len) {
+        while(right < len && sum < s) {
+            sum += nums[++right];
+        }
+        if(sum >= s) {
+            minLen = Math.min(right - left + 1, minLen);
+            sum -= nums[left];
+            left++;
+        }
+        
+    }
+    
+    
+    
+    return minLen > len ? 0 : minLen;
+};

31 Next Permutation.js

@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+//  http://fisherlei.blogspot.com/2012/12/leetcode-next-permutation.html
+var nextPermutation = function(nums) {
+    var vioIndex = nums.length - 1;
+    
+    while(vioIndex > 0) {
+        if(nums[vioIndex - 1] < nums[vioIndex]) {
+            break;
+        }
+        vioIndex--;
+    }
+    
+    if(vioIndex > 0) {
+        vioIndex--;
+        var first = nums.length - 1;
+        while(first > vioIndex && nums[first] <= nums[vioIndex]){
+            first--;
+        }
+        
+        var temp = nums[vioIndex];
+        nums[vioIndex] = nums[first];
+        nums[first] = temp;
+        
+        vioIndex++;
+    }
+    
+    var end = nums.length - 1;
+    
+    while(end > vioIndex) {
+        temp = nums[end];
+        nums[end] = nums[vioIndex];
+        nums[vioIndex] = temp;
+        
+        end--;
+        vioIndex++;
+    }
+};

49 Group Anagrams.js

@@ -0,0 +1,37 @@
+/**
+ * @param {string[]} strs
+ * @return {string[][]}
+ */
+ 
+
+
+var groupAnagrams = function(strs) {
+    var hash = {}
+    
+    for(var i = 0; i < strs.length; i++) {
+        var str = strs[i];
+        var sortedStr = sort(str);
+        
+        hash[sortedStr] = hash[sortedStr] || [];
+        hash[sortedStr].push(str);
+    }
+    
+    var result = [];
+    
+    for(i in hash) {
+        var arr = hash[i].sort(function (a,b) {
+            return a > b ? 1 : -1;
+        });
+        result.push(arr);
+    }
+    return result;
+};
+
+var sort = function(s) {
+    var arr = s.split('');
+    arr.sort(function (a,b) {
+        return a > b ? 1 : -1;
+    });
+    
+    return arr.join('');
+}

50 Pow(x, n).js

@@ -0,0 +1,21 @@
+/**
+ * @param {number} x
+ * @param {number} n
+ * @return {number}
+ */
+ 
+//  http://blog.csdn.net/sunnyyoona/article/details/43273933
+var myPow = function(x, n) {
+    if(n < 0)   {
+        return 1.0/myPow(x, -n);
+    }
+    if(n === 0) {
+        return 1.0;
+    }
+    if(n === 1) {
+        return x;
+    }
+    
+    var sub = myPow(x, parseInt(n/2));
+    return sub*sub*myPow(x, n%2);
+};