Merge branch 'master' of https://github.com/jyxia/LeetCode-JavaScript

Author: jyxia

Easy/344-reverseString.js

@@ -0,0 +1,7 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var reverseString = function(s) {
+    return s.split('').reverse().join('');
+};

Easy/349-intersectionTwoArrays.js

@@ -0,0 +1,61 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+// use hashset idea, O(N)
+var intersection = function(nums1, nums2) {
+    // Note ES5 doesn't have set
+    var set1 = new Set();
+    var interSet = new Set();
+    for (var i = 0; i < nums1.length; i++) {
+        set1.add(nums1[i]);
+    }
+
+    for (var j = 0; j < nums2.length; j++) {
+        if (set1.has(nums2[j])) {
+            interSet.add(nums2[j]);
+        }
+    }
+
+    var result = [];
+    interSet.forEach(function(item) {
+        result.push(item);
+    });
+
+    return result;
+};
+
+// solution 2: sort first. O(nlogn)
+var intersection = function(nums1, nums2) {
+    // Note ES5 doesn't have set
+    var interSet = new Set();
+    nums1.sort(comparator);
+    nums2.sort(comparator);
+    var i = 0;
+    var j = 0;
+
+    while (i < nums1.length) {
+        if (j === nums2.length) break;
+        if (nums1[i] < nums2[j]) {
+            i++;
+        } else if (nums1[i] > nums2[j]) {
+            j++;
+        } else {
+            interSet.add(nums1[i]);
+            i++;
+            j++;
+        }
+    }
+
+    var result = [];
+    interSet.forEach(function(item) {
+        result.push(item);
+    });
+
+    return result;
+};
+
+var comparator = function(a, b) {
+    return a - b;
+};

Easy/350-intersectionTwoArraysII.js

@@ -0,0 +1,56 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+var intersect = function(nums1, nums2) {
+    var hashMap = {};
+    for (var i = 0; i < nums1.length; i++) {
+        if (hashMap.hasOwnProperty(nums1[i])) {
+            hashMap[nums1[i]]++;
+        } else {
+            hashMap[nums1[i]] = 1;
+        }
+    }
+    var hashMap2 = {};
+    for (i = 0; i < nums2.length; i++) {
+        if (hashMap2.hasOwnProperty(nums2[i])) {
+            hashMap2[nums2[i]]++;
+        } else {
+            hashMap2[nums2[i]] = 1;
+        }
+    }
+
+    var result = [];
+    for (var key in hashMap) {
+        if (!hashMap2.hasOwnProperty(key)) continue;
+        var numAppears = Math.min(hashMap[key], hashMap2[key]);
+        for (i = 0; i < numAppears; i++) {
+            result.push(parseInt(key));
+        }
+    }
+
+    return result;
+};
+
+// A better and more concise solution. One hashmap needed.
+var intersect = function(nums1, nums2) {
+    var hashMap = {};
+    for (var i = 0; i < nums1.length; i++) {
+        if (hashMap.hasOwnProperty(nums1[i])) {
+            hashMap[nums1[i]]++;
+        } else {
+            hashMap[nums1[i]] = 1;
+        }
+    }
+
+    var result = [];
+    for (i = 0; i < nums2.length; i++) {
+        if (hashMap.hasOwnProperty(nums2[i]) && hashMap[nums2[i]] > 0) {
+            result.push(nums2[i]);
+            hashMap[nums2[i]]--;
+        }
+    }
+
+    return result;
+};

Medium/129-sumRootToLeafNumbers.js

@@ -47,3 +47,19 @@ var helper = function(root, sum) {
     return  helper(root.left, 10 * sum + root.val)
             + helper(root.right, 10 * sum + root.val);
 };
+
+// a third DFS method. Top-down
+var sumNumbers = function(root) {
+    if (!root) return 0;
+    return helper(root, 0, 0);
+};
+
+function helper(root, currNum, sum) {
+    if (!root) return sum;
+    currNum = root.val + 10 * currNum;
+    if (!root.left && !root.right) {
+        sum += currNum;
+        return sum;
+    }
+    return helper(root.left, currNum, sum) + helper(root.right, currNum, sum)
+}

Medium/147-insertionSortList.js

@@ -0,0 +1,37 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var insertionSortList = function(head) {
+    if (!head) return head;
+    var dummyHead = new ListNode(null);
+    dummyHead.next = head;
+    var first = dummyHead;
+    var second = head;
+
+    while (second.next) {
+        if (second.next.val < second.val) {
+            var smallNode = second.next;
+            second.next = second.next.next;
+            while (first.next && first.next.val < smallNode.val) {
+                first = first.next;
+            }
+            smallNode.next = first.next;
+            first.next = smallNode;
+            first = dummyHead;
+        } else {
+            second = second.next;
+            if (!second) break;
+        }
+
+    }
+
+    return dummyHead.next;
+};

Medium/148-sortList.js

@@ -0,0 +1,48 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * sort, then merge. In fact, this method use O(logN) space for recursive function calls.
+ * needs to be improved.
+ *
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var sortList = function(head) {
+    if (!head || !head.next) return head;
+    var fast = head;
+    var slow = head;
+
+    while (fast.next && fast.next.next) {
+        slow = slow.next;
+        fast = fast.next.next;
+    }
+    fast = slow.next;
+    slow.next = null;
+    var secondHalf = sortList(fast);
+    var firstHalf = sortList(head);
+    return merge(firstHalf, secondHalf);
+};
+
+var merge = function(l1, l2) {
+    var l3 = new ListNode();
+    var l3Head = l3;
+    while (l1 && l2) {
+        if (l1.val <= l2.val ) {
+            l3.next = l1;
+            l1 = l1.next;
+        } else {
+            l3.next = l2;
+            l2 = l2.next;
+        }
+        l3 = l3.next;
+    }
+    if (!l1) l3.next = l2;
+    if (!l2) l3.next = l1;
+
+    return l3Head.next;
+};

Medium/150-reversePolishNotation.js

@@ -0,0 +1,30 @@
+/**
+ * @param {string[]} tokens
+ * @return {number}
+ */
+// seems like it is not a good solution
+var evalRPN = function(tokens) {
+    var stack = [];
+    for (var i = 0; i < tokens.length; i++) {
+        var token = tokens[i];
+        if (!isNaN(token)) {
+            stack.push(token);
+        } else {
+            var num1 = stack.pop();
+            var num2 = stack.pop();
+            var result = getResult(num2, num1, token);
+            stack.push(result);
+        }
+    }
+
+    return Math.floor(parseInt(stack[stack.length - 1]));
+};
+
+var getResult = function(num1, num2, operator) {
+    var a = parseInt(num1);
+    var b = parseInt(num2);
+    if (operator === '+') return a + b;
+    if (operator === '-') return a - b;
+    if (operator === '/') return a / b;
+    if (operator === '*') return a * b;
+};

Medium/338-countingBits.js

@@ -0,0 +1,15 @@
+/**
+ * Solution: f(i) = f(i/2) + i % 2;
+ * the bit nums = the bit nums of half of the number, and plus 1 if the last digit of the bit number is 1.
+ *
+ * @param {number} num
+ * @return {number[]}
+ */
+var countBits = function(num) {
+    var result = [0];
+    for (var i = 1; i <= num; i++) {
+        result[i] = result[i >> 1] + (i & 1);
+    }
+
+    return result;
+};

README.md

@@ -68,9 +68,11 @@
 * [326. Power of Three](https://leetcode.com/problems/power-of-three/) - [Solution](./Easy/326-powerOfThree.js)
 * [328. Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/) - [Solution](./Easy/328-oddevenLinkedList.js)
 * [342. Power of Four](https://leetcode.com/problems/power-of-four/) - [Solution](./Easy/342-powerOfFour.js)
+* [344. Reverse String](https://leetcode.com/problems/reverse-string/) - [Solution](./Easy/344-reverseString.js)
+* [349. Intersection of Two Arrays](https://leetcode.com/problems/intersection-of-two-arrays/) - [Solution](./Easy/349-intersectionTwoArrays.js)
+* [350. Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/) - [Solution](./Easy/349-intersectionTwoArraysII.js)
 * [412. Fizz Buzz](https://leetcode.com/problems/fizz-buzz/?tab=Solutions) - [Solution](./Easy/412-fizzBuzz.js)
 
-
 ##### Medium
 * [1. Two Sum](https://leetcode.com/problems/two-sum/) - [Solution](./Medium/1-twoSum.js)
 * [2. Add Two Numbers](https://leetcode.com/problems/add-two-numbers/) - [Solution](./Medium/2-addTwoNumbers.js)
@@ -145,6 +147,9 @@
 * [142. Linked List Cycle II](https://leetcode.com/problems/linked-list-cycle-ii/) - [Solution](./Medium/142-linkedListCycleII.js)
 * [143. Reorder List](https://leetcode.com/problems/reorder-list/) - [Solution](./Medium/143-reorderList.js)
 * [144. Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/) - [Solution](./Medium/144-binaryTreePreorder.js)
+* [147. Insertion Sort List](https://leetcode.com/problems/insertion-sort-list/) - [Solution](./Medium/147-insertionSortList.js)
+* [148. Sort List](https://leetcode.com/problems/sort-list/) - [Solution](./Medium/148-sortList.js)
+* [150. Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/) - [Solution](./Medium/150-reversePolishNotation.js)
 * [151. Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/) - [Solution](./Medium/151-reverseWordsInAString.js)
 * [152. Maximum Product Subarray](https://leetcode.com/problems/maximum-product-subarray/) - [Solution](./Medium/152-MaxProductSubarray.js)
 * [153.	Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/) - [Solution](./Medium/153-findMinimumInRotatedSortedArray.js)
@@ -171,6 +176,7 @@
 * [319. Bulb Switcher](https://leetcode.com/problems/bulb-switcher/) - [Solution](./Medium/319-bulbSwitcher.js)
 * [331. Verify Preorder Serialization of a Binary Tree](https://leetcode.com/problems/verify-preorder-serialization-of-a-binary-tree/) - [Solution](./Medium/331-verifyBinaryTree.js)
 * [337. House Robber III](https://leetcode.com/problems/house-robber-iii/) - [Solution](./Medium/337-houseRobberIII.js)
+* [338. Counting Bits](https://leetcode.com/problems/counting-bits/) - [Solution](./Medium/338-countingBits.js)
 * [347. Top K Frequent Elements](https://leetcode.com/problems/top-k-frequent-elements/) - [Solution](./Medium/247-topKFrequentElements.js)
 
 ##### Hard