add some new files

Author: chihungyu1116

10 Regular Expresion Matching.js

@@ -0,0 +1,74 @@
+// https://www.youtube.com/watch?v=l3hda49XcDE#t=211.113333
+
+// Implement regular expression matching with support for '.' and '*'.
+
+// '.' Matches any single character.
+// '*' Matches zero or more of the preceding element.
+
+// The matching should cover the entire input string (not partial).
+
+// The function prototype should be:
+// bool isMatch(const char *s, const char *p)
+
+// Some examples:
+// isMatch("aa","a") → false
+// isMatch("aa","aa") → true
+// isMatch("aaa","aa") → false
+// isMatch("aa", "a*") → true
+// isMatch("aa", ".*") → true
+// isMatch("ab", ".*") → true
+// isMatch("aab", "c*a*b") → true
+
+
+/**
+ * @param {string} s
+ * @param {string} p
+ * @return {boolean}
+ */
+var isMatch = function(s, p) {
+    var m = s.length;
+    var n = p.length;
+    var dp = [];
+    
+    for(var i = 0; i <= m; i++) {
+        var tmp = [];
+        
+        for(var j = 0; j <= n; j++) {
+            tmp.push(false);
+        }
+        
+        dp.push(tmp);
+    }
+    
+    dp[0][0] = true;
+    
+    for(i = 0; i <= m; i++) {
+        for(j = 0; j <= n; j++) {
+            if(p[j-1] !== '.' && p[j-1] !== '*') {
+                if(i > 0 && s[i-1] === p[j-1] && dp[i-1][j-1]) {
+                    dp[i][j] = true;
+                }
+            } else if(p[j-1] === '.') {
+                if(i > 0 && dp[i-1][j-1]) {
+                  dp[i][j] = true;
+                }
+            } else if(j > 1) { // '*' cannot be the first element      
+                if(dp[i][j-1] || dp[i][j-2]) {
+                  dp[i][j] = true;     
+                } else if(i > 0 && (p[j-2] == s[i-1] || p[j-2] == '.') && dp[i-1][j]) {
+
+                  // example
+                  // xa and xa* 
+                  // s[i-1] === a
+                  // p[j-2] === a
+                  // a === a
+                  // so we can now compare x, xa*
+                  // and x here is dp[i-1][j]
+                    dp[i][j] = true; 
+                }
+            }
+        }
+    }
+    
+    return dp[m][n];
+};

146 LRU Cache.js

@@ -0,0 +1,101 @@
+// Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.
+
+// get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
+// set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.
+class Node {
+    constructor(key, val) {
+        this.key = key;
+        this.val = val;
+        this.next = null;
+        this.prev = null;
+    }
+}
+/**
+ * @constructor
+ */
+var LRUCache = function(capacity) {
+    this.list = null;
+    this.map = new Map();
+    this.head = null;
+    this.tail = null;
+    this.size = capacity;
+    this.curSize = 0;
+};
+
+/**
+ * @param {number} key
+ * @returns {number}
+ */
+LRUCache.prototype.get = function(key) {
+    if (!this.map.get(key)) {
+        return -1;
+    }
+    
+    let node = this.map.get(key);
+    
+    if (node === this.head) {
+        return node.val;
+    }
+    
+    // remove node from list
+    if (node === this.tail) {
+        this.tail.prev.next = null;
+        this.tail = this.tail.prev;
+    } else {
+        node.prev.next = node.next;
+        node.next.prev = node.prev;
+    }
+    
+    // insert node to head
+    node.next = this.head;
+    this.head.prev = node;
+    this.head = node;
+    
+    return node.val;
+};
+
+/**
+ * @param {number} key
+ * @param {number} value
+ * @returns {void}
+ */
+LRUCache.prototype.set = function(key, value) {
+    let newNode = new Node(key, value);
+    
+    if (this.curSize === 0) {
+        this.tail = newNode;
+    } else {
+        newNode.next = this.head;
+        this.head.prev = newNode;
+    }
+    
+    this.head = newNode;
+    this.curSize++;
+    
+    // update
+    if (this.map.get(key)) {
+        let oldNode = this.map.get(key);
+        
+        // remove node
+        if (oldNode === this.tail) {
+            this.tail = this.tail.prev;
+            this.tail.next = null;
+        } else {
+            oldNode.prev.next = oldNode.next;
+            oldNode.next.prev = oldNode.prev;
+        }
+        
+        this.curSize--;
+        
+    } else {
+        if (this.curSize > this.size) {
+            //delete tail
+            this.map.delete(this.tail.key);
+            this.tail = this.tail.prev;
+            this.tail.next = null;
+            this.curSize--;
+        }
+    }
+    
+    this.map.set(key, newNode);
+};

222. Count Complete Tree Nodes.js

@@ -0,0 +1,38 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var countNodes = function(root) {
+    return treeNodes(root);
+
+    function treeNodes(node){
+        if(!node){
+            return 0;
+        }else{
+            var leftDepth = 0;
+            var rightDepth = 0;
+            var leftChild = node.left;
+            while(leftChild){
+                leftDepth++;
+                leftChild = leftChild.left;
+            }
+            var rightChild = node.right;
+            while(rightChild){
+                rightDepth++;
+                rightChild = rightChild.right;
+            }
+            if(leftDepth === rightDepth){
+                return Math.pow(2, leftDepth + 1) - 1;
+            }else{
+                return treeNodes(node.left) + treeNodes(node.right) + 1;
+            }
+        }
+    }
+};

236 Lowest Common Ancestor of a Binary Tree.js

@@ -0,0 +1,30 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+ 
+//  http://www.cnblogs.com/anne-vista/p/4815076.html
+var lowestCommonAncestor = function(root, p, q) {
+    if(root === null || root === p || root === q) {
+        return root;
+    }
+    
+    var l = lowestCommonAncestor(root.left, p, q);
+    var r = lowestCommonAncestor(root.right, p, q);
+    
+    if(l !== null && r !== null) {
+        // p and q are on two different side of root node.
+        return root;
+    }
+    
+    return (l !== null) ? l : r; // either one of p, q is on one side OR p, q is not in l&r subtrees
+};

257 Binary Tree Paths.js

@@ -0,0 +1,53 @@
+// Given a binary tree, return all root-to-leaf paths.
+
+// For example, given the following binary tree:
+
+//    1
+//  /   \
+// 2     3
+//  \
+//   5
+// All root-to-leaf paths are:
+
+// ["1->2->5", "1->3"]
+
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {string[]}
+ */
+var binaryTreePaths = function(root) {
+    var result = [];
+    
+    if(root !== null) {
+        traverse(root, [], result);
+    }
+    
+    return result;
+};
+
+var traverse = function(node, path, result) {
+    path.push(node.val);
+    
+    if(node.left || node.right) {
+        if(node.left) {
+            traverse(node.left, path, result);
+            path.pop();
+        }
+    
+        if(node.right) {
+            traverse(node.right, path, result);
+            path.pop();
+        }   
+        // path.pop()
+    } else {
+        result.push(path.join("->"));
+    }
+}

263 Ugly Number.js

@@ -0,0 +1,27 @@
+// 263. Ugly Number
+
+// Write a program to check whether a given number is an ugly number.
+
+// Ugly numbers are positive numbers whose prime factors only include 2, 3, 5. For example, 6, 8 are ugly while 14 is not ugly since it includes another prime factor 7.
+
+// Note that 1 is typically treated as an ugly number.
+
+/**
+ * @param {number} num
+ * @return {boolean}
+ */
+var isUgly = function(num) {
+    while(num >= 2) {
+        if(num%2 === 0) {
+            num /= 2;
+        } else if(num%3 === 0) {
+            num /= 3;
+        } else if(num%5 === 0) {
+            num /= 5;
+        } else {
+            return false;
+        }
+    }
+    
+    return num === 1;
+};

264 Ugly Number II.js

@@ -0,0 +1,41 @@
+// 264. Ugly Number II
+
+// Write a program to find the n-th ugly number.
+
+// Ugly numbers are positive numbers whose prime factors only include 2, 3, 5. For example, 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 is the sequence of the first 10 ugly numbers.
+
+// Note that 1 is typically treated as an ugly number.
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var nthUglyNumber = function(n) {
+    var uglys = [1];
+    var p2 = 0;
+    var p3 = 0;
+    var p5 = 0;
+    
+    while(uglys.length < n) {
+        var ugly2 = uglys[p2]*2;
+        var ugly3 = uglys[p3]*3;
+        var ugly5 = uglys[p5]*5;
+        
+        var minV = Math.min(ugly2, ugly3, ugly5);
+        
+        if(minV === ugly2) {
+            p2++;
+        }
+        if(minV === ugly3) {
+            p3++;
+        }
+        if(minV === ugly5) {
+            p5++;
+        }
+        if(minV !== uglys[uglys.length - 1]) {
+            uglys.push(minV);
+        }
+    }
+    
+    return uglys[n-1];
+};