diff --git a/javascript/1-Two-Sum.js b/javascript/1-Two-Sum.js
new file mode 100644
index 000000000..56e9b10fe
--- /dev/null
+++ b/javascript/1-Two-Sum.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(nums, target) {
+    let map = {};
+    for (let i = 0; i < nums.length; i++) {
+        if (target - nums[i] in map) {
+            return [map[target-nums[i]], i];
+        } else {
+            map[nums[i]] = i;
+        }
+    }
+};
diff --git a/javascript/100-Same-Tree.js b/javascript/100-Same-Tree.js
new file mode 100644
index 000000000..25db45766
--- /dev/null
+++ b/javascript/100-Same-Tree.js
@@ -0,0 +1,18 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+var isSameTree = function(p, q) {
+    if (!p && !q) return true;
+    if (!p || !q || p.val !== q.val) return false; 
+    return isSameTree(p.right,q.right) && isSameTree(p.left, q.left);
+};
diff --git a/javascript/104-Maximum-Depth-of-Binary-Tree.js b/javascript/104-Maximum-Depth-of-Binary-Tree.js
new file mode 100644
index 000000000..7cf81388a
--- /dev/null
+++ b/javascript/104-Maximum-Depth-of-Binary-Tree.js
@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxDepth = (root) => {
+    let maxDepth = 0;
+    let DFS = (node, depth) => {
+        if (!node) return maxDepth;
+        if (depth > maxDepth) maxDepth = depth;
+        DFS(node.right, depth + 1);
+        DFS(node.left, depth + 1);
+    }
+    DFS(root, 1);
+    return maxDepth;
+};
diff --git a/javascript/11-Container-With-Most-Water.js b/javascript/11-Container-With-Most-Water.js
new file mode 100644
index 000000000..11b35406d
--- /dev/null
+++ b/javascript/11-Container-With-Most-Water.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var maxArea = function(height) {
+    let max = 0;
+    let i = 0;
+    let j = height.length - 1;
+    
+    while (i < j) {
+        curr = (j - i) * Math.min(height[i], height[j]);
+        max = Math.max(curr, max);
+        if (height[i] > height[j]) {
+            j--;
+        } else {
+            i++;
+        }
+    }
+    return max;
+};
diff --git a/javascript/121-Best-Time-to-Buy-and-Sell-Stock.js b/javascript/121-Best-Time-to-Buy-and-Sell-Stock.js
new file mode 100644
index 000000000..c8436d470
--- /dev/null
+++ b/javascript/121-Best-Time-to-Buy-and-Sell-Stock.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+var maxProfit = function(prices) {
+    let buy = prices[0];
+    let profit = 0; 
+    for (let i = 0; i < prices.length; i++) {
+        if (prices[i] < buy) {
+            buy = prices[i];
+        } else {
+            profit = Math.max(prices[i] - buy, profit);
+        }
+    }
+    return profit;
+};
diff --git a/javascript/125-Valid-Palindrome.js b/javascript/125-Valid-Palindrome.js
new file mode 100644
index 000000000..d953b3802
--- /dev/null
+++ b/javascript/125-Valid-Palindrome.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isPalindrome = function(s) {
+    s = s.toLowerCase();
+    s = s.replace(/[^A-Z0-9]/gi, '');
+    
+    let i = 0
+    let j = s.length - 1;
+    
+    while (i < j) {
+        if (s[i] !== s[j]) return false;
+        
+        i++;
+        j--
+    }
+    return true;
+};
diff --git a/javascript/141-Linked-List-Cycle.js b/javascript/141-Linked-List-Cycle.js
new file mode 100644
index 000000000..d79850599
--- /dev/null
+++ b/javascript/141-Linked-List-Cycle.js
@@ -0,0 +1,25 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+
+/**
+ * @param {ListNode} head
+ * @return {boolean}
+ */
+var hasCycle = function(head) {
+    let set = new Set(); 
+    while (head) {
+        if (set.has(head)) {
+            return true;
+        } else {
+            set.add(head);
+            head = head.next;
+        }
+    }
+    
+    return false;
+};
diff --git a/javascript/143-Reorder-List.js b/javascript/143-Reorder-List.js
new file mode 100644
index 000000000..dbc5468a0
--- /dev/null
+++ b/javascript/143-Reorder-List.js
@@ -0,0 +1,50 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {void} Do not return anything, modify head in-place instead.
+ */
+var reorderList = function(head) {
+    if (!head) { return };
+    
+    let slow = head;
+    let fast = head;
+    
+    
+    // finding the middle of the linked list using 2 pters
+    while (fast && fast.next) {
+        slow = slow.next;
+        fast = fast.next.next;
+    }
+    
+    // reverse the second part of the list starting at slow
+    let prev = null
+    let curr = slow; 
+    while (curr) {
+        let next = curr.next;
+        curr.next = prev;
+        prev = curr;
+        curr = next;
+    } // here prev is the head 
+    
+    // merge two sorted lists (first one starts at head, second at prev)
+    let first = head;
+    let second = prev;
+    
+    while(second.next) {
+        temp = first.next;
+        first.next = second;
+        first = temp;
+        
+        temp = second.next;
+        second.next = first;
+        second = temp;
+    }
+    
+    
+};
diff --git a/javascript/15-3Sum.js b/javascript/15-3Sum.js
new file mode 100644
index 000000000..db5aaffcb
--- /dev/null
+++ b/javascript/15-3Sum.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var threeSum = function(nums) {
+    let res = [];
+    let left = 0;
+    let right = nums.length - 1;
+    nums.sort((a,b) => { return a - b })
+    
+    for (let i = 0; i < nums.length - 1; i++) {
+        if (nums[i] > 0) return res;
+        if (nums[i] === nums[i - 1]) continue;
+        
+        left = i + 1;
+        right = nums.length - 1;
+        let temp = 0;
+        
+        while (left < right) {
+            temp = nums[left] + nums[right] + nums[i];
+            if (temp === 0) {
+                res.push([nums[i], nums[left], nums[right]]);
+                left++;
+                right--;
+            
+            while(nums[left] == nums[left - 1]) { left++ };
+            
+            while (nums[right] == nums[right - 1]) { right-- };
+            
+            } else if (temp > 0) { right-- }
+            else if (temp < 0) { left++ }
+        }
+    }
+    return res;
+};
diff --git a/javascript/152-Maximum-Product-Subarray.js b/javascript/152-Maximum-Product-Subarray.js
new file mode 100644
index 000000000..64519e177
--- /dev/null
+++ b/javascript/152-Maximum-Product-Subarray.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxProduct = function(nums) {
+    let result = nums[0];
+    let prevMax = nums[0];
+    let prevMin = nums[0];
+    for(let i = 1; i < nums.length; i++) {
+        currMax = Math.max(nums[i], prevMax * nums[i], prevMin * nums[i]);
+        currMin = Math.min(nums[i], prevMax * nums[i], prevMin * nums[i]);
+        
+        prevMax = currMax;
+        prevMin = currMin;
+        
+        result = Math.max(currMax, result);
+    }
+    return result;
+
+};
diff --git a/javascript/153-Find-Minimum-in-Rotated-Sorted-Array.js b/javascript/153-Find-Minimum-in-Rotated-Sorted-Array.js
new file mode 100644
index 000000000..2c28650e2
--- /dev/null
+++ b/javascript/153-Find-Minimum-in-Rotated-Sorted-Array.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMin = function(nums) {
+    let left = 0;
+    let right = nums.length - 1;
+    while (right > left) {
+        let mid = Math.floor((right + left) / 2);
+        if (nums[mid] > nums[right]) {
+            left = mid + 1;
+        } else {
+            right = mid;
+        }  
+    }
+    return nums[left];
+};
diff --git a/javascript/19-Remove-Nth-Node-From-End-of-List.js b/javascript/19-Remove-Nth-Node-From-End-of-List.js
new file mode 100644
index 000000000..e52e76058
--- /dev/null
+++ b/javascript/19-Remove-Nth-Node-From-End-of-List.js
@@ -0,0 +1,32 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} n
+ * @return {ListNode}
+ */
+var removeNthFromEnd = function(head, n) {
+    let currNode = head;
+    let nodeBeforeN = head;
+    
+    for (let i = 0; i < n; i++) {
+        currNode = currNode.next;
+    }
+    
+    if (!currNode) { return head.next }
+    
+    while (currNode.next) {
+        nodeBeforeN = nodeBeforeN.next;
+        currNode = currNode.next;
+    }
+    
+    nodeBeforeN.next = nodeBeforeN.next.next;
+    
+    return head;
+     
+};
diff --git a/javascript/20-Valid-Parentheses.js b/javascript/20-Valid-Parentheses.js
new file mode 100644
index 000000000..149722b31
--- /dev/null
+++ b/javascript/20-Valid-Parentheses.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isValid = function(s) {
+    
+    let closeMap = {
+        '}' :'{',
+        ')' : '(',
+        ']' : '['
+    };
+    
+    let charStack = [];
+    
+    if (!s) return false;
+    
+    for (let i = 0; i < s.length; i++) {
+        let curr = s.charAt(i);
+        // check if closing bracket
+        if (closeMap[curr]) {
+            topElement = (charStack.length === 0) ? '#' : charStack.pop();
+            if (topElement !== closeMap[curr]) {
+                return false;
+            }
+            // opening bracket case
+        } else {
+            charStack.push(curr);
+        }
+    }
+    
+    return charStack.length === 0;
+};
diff --git a/javascript/206-Reverse-Linked-List.js b/javascript/206-Reverse-Linked-List.js
new file mode 100644
index 000000000..15bbbf0ff
--- /dev/null
+++ b/javascript/206-Reverse-Linked-List.js
@@ -0,0 +1,23 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var reverseList = function(head) {
+    let prev = null;
+    
+    while (head) {
+        let next = head.next;
+        head.next = prev;
+        prev = head;
+        head = next;
+    }
+    
+    return prev;
+};
diff --git a/javascript/21-Merge-Two-Sorted-Lists.js b/javascript/21-Merge-Two-Sorted-Lists.js
new file mode 100644
index 000000000..a9e155607
--- /dev/null
+++ b/javascript/21-Merge-Two-Sorted-Lists.js
@@ -0,0 +1,28 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} list1
+ * @param {ListNode} list2
+ * @return {ListNode}
+ */
+var mergeTwoLists = function(l1, l2) {
+    let nullNode = { val : 0, next : null};
+    let prev = nullNode;
+    while (l1 && l2) {
+        if (l1.val >= l2.val) {
+            prev.next = l2;
+            l2 = l2.next;
+        } else {
+            prev.next = l1;
+            l1 = l1.next;
+        }
+        prev = prev.next; 
+    }
+    prev.next = l1 || l2;
+    return nullNode.next;
+};
diff --git a/javascript/217-Contains-Duplicate.js b/javascript/217-Contains-Duplicate.js
new file mode 100644
index 000000000..3c96a1b20
--- /dev/null
+++ b/javascript/217-Contains-Duplicate.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var containsDuplicate = function(nums) {
+    let map = {};
+    
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] in map) {
+            return true;
+        } else {
+            map[nums[i]] = i;
+        }
+    }
+    return false;
+};
diff --git a/javascript/226-Invert-Binary-Tree.js b/javascript/226-Invert-Binary-Tree.js
new file mode 100644
index 000000000..33888e1d4
--- /dev/null
+++ b/javascript/226-Invert-Binary-Tree.js
@@ -0,0 +1,20 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+var invertTree = function(root) {
+    if (!root) return root;
+    let left = root.left;
+    root.left = invertTree(root.right);
+    root.right = invertTree(left);
+    return root;
+    
+};
diff --git a/javascript/238-Product-of-Array-Except-Self.js b/javascript/238-Product-of-Array-Except-Self.js
new file mode 100644
index 000000000..819d9075b
--- /dev/null
+++ b/javascript/238-Product-of-Array-Except-Self.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var productExceptSelf = function(nums) {
+    const res = [];
+    
+    let product = 1;
+    
+    for (let i = 0; i < nums.length; i++) {
+        res[i] = product;
+        product *= nums[i];
+    }
+    product = 1;
+    for (let j = nums.length - 1; j >= 0; j--) {
+        res[j] *= product;
+        product *= nums[j];
+    }
+    
+    return res;
+    
+};
diff --git a/javascript/242-Valid-Anagram.js b/javascript/242-Valid-Anagram.js
new file mode 100644
index 000000000..0447a7774
--- /dev/null
+++ b/javascript/242-Valid-Anagram.js
@@ -0,0 +1,34 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function(s, t) {
+    let map = {};
+    
+    if (s.length !== t.length) {
+        return false;
+    }
+    
+    for (let i = 0; i < s.length; i++) {
+        if (map[s[i]]) {
+            map[s[i]]++;
+        } else {
+            map[s[i]] = 1;
+        }
+    }
+    
+    for (let i = 0;  i < t.length; i++) {
+        if (map[t[i]]) {
+            map[t[i]]--;
+        } else {
+            return false;
+        }
+    }
+    
+    return true;
+    
+    
+    
+    
+};
diff --git a/javascript/268-Missing-Number.js b/javascript/268-Missing-Number.js
new file mode 100644
index 000000000..04159deae
--- /dev/null
+++ b/javascript/268-Missing-Number.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function(nums) {
+    nums.sort((a,b) => {return a-b});
+    
+    if (nums[nums.length - 1] !== nums.length) {
+        return nums.length;
+    } else if (nums[0] !== 0) {
+        return 0;
+    }
+    
+    for (let i = 0; i < nums.length; i++) {
+        if(nums[i + 1] !== nums[i] + 1) {
+            return nums[i] + 1;
+        }
+    }
+    
+    return -1;
+    
+    
+    
+};
diff --git a/javascript/300-Longest-Increasing-Subsequence.js b/javascript/300-Longest-Increasing-Subsequence.js
new file mode 100644
index 000000000..d7b63b06c
--- /dev/null
+++ b/javascript/300-Longest-Increasing-Subsequence.js
@@ -0,0 +1,12 @@
+var lengthOfLIS = function(nums) {
+    let arr = Array(nums.length).fill(1);
+    
+    for(let i = 1; i < arr.length; i++) {
+        for (let j = 0; j < i; j++) {
+            if (nums[i] > nums[j]) {
+                arr[i] = Math.max(arr[i], arr[j] + 1);
+            }
+        }
+    }
+    return Math.max(...arr);
+};
diff --git a/javascript/33-Search-in-Rotated-Sorted-Array.js b/javascript/33-Search-in-Rotated-Sorted-Array.js
new file mode 100644
index 000000000..97d83dcc9
--- /dev/null
+++ b/javascript/33-Search-in-Rotated-Sorted-Array.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var search = function(nums, target) {
+  let left = 0;
+  let right = nums.length - 1;
+    
+  while (left <= right) {
+    let mid = Math.floor((left + right) / 2);
+    
+    if (nums[mid] === target) {
+      return mid;
+    }
+    
+    // Checking if the left side is sorted
+    if (nums[left] <= nums[mid]) {
+      if (nums[left] <= target && target <= nums[mid]) {
+        // thus target is in the left
+        right = mid - 1;
+        
+      } else {
+        // thus target is in the right
+        left = mid + 1;
+      }
+    } 
+    
+    // Otherwise, the right side is sorted
+    else {
+      if (nums[mid] <= target && target <= nums[right]) {
+        // thus target is in the right
+        left = mid + 1;
+
+      } else {
+        // thus target is in the left
+        right = mid - 1;
+      }
+    }
+    
+  }
+    
+  return -1;
+};
diff --git a/javascript/49-Rotate-Image.js b/javascript/49-Rotate-Image.js
new file mode 100644
index 000000000..7508b0a8d
--- /dev/null
+++ b/javascript/49-Rotate-Image.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[][]} matrix
+ * @return {void} Do not return anything, modify matrix in-place instead.
+ */
+var rotate = function(matrix) {
+    transpose(matrix);
+    reflect(matrix);
+};
+
+var transpose = function(matrix) {
+    let n = matrix.length;
+    for (let i = 0; i < n; i++) {
+        for (let j = i + 1; j < n; j++) {
+            let temp = matrix[j][i];
+            matrix[j][i] = matrix[i][j];
+            matrix[i][j] = temp;
+        }
+    }
+}
+
+var reflect = function(matrix) {
+    let n = matrix.length;
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n / 2; j++) {
+            let temp = matrix[i][j];
+            matrix[i][j] = matrix[i][n - j - 1];
+            matrix[i][n - j - 1] = temp;
+        }
+    }
+}
diff --git a/javascript/53-Maximum-Subarray.js b/javascript/53-Maximum-Subarray.js
new file mode 100644
index 000000000..171bcbfc4
--- /dev/null
+++ b/javascript/53-Maximum-Subarray.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSubArray = function(nums) {
+    let curr = nums[0];
+    let max = nums[0];
+    
+    for (let i = 1; i < nums.length; i++) {
+        curr = Math.max(curr + nums[i], nums[i]);
+        max = Math.max(max, curr)
+    }
+    return max;
+};
diff --git a/javascript/54-Spiral-Matrix.js b/javascript/54-Spiral-Matrix.js
new file mode 100644
index 000000000..9d27c5f4c
--- /dev/null
+++ b/javascript/54-Spiral-Matrix.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number[]}
+ */
+var spiralOrder = function(matrix) {
+    const results = []
+    let startRow = 0, startCol = 0, endRow = matrix.length-1, endCol = matrix[0].length-1;
+    
+    while(results.length < matrix.length * matrix[0].length) {
+        
+        for(let col = startCol; col <= endCol; col++ ) {
+            results.push(matrix[startRow][col])
+        }
+        
+        for(let row = startRow + 1; row <= endRow; row++) {
+            results.push(matrix[row][endCol])
+        }
+        
+        for(let col = endCol - 1; col >= startCol; col--) {
+            if(startRow === endRow) break;
+            results.push(matrix[endRow][col])
+        }
+        
+        for(let row = endRow - 1; row >= startRow + 1; row--) {
+            if(endCol === startCol) break;
+            results.push(matrix[row][startCol])
+        }
+        
+        startRow++
+        startCol++
+        endRow--
+        endCol--
+    }
+    
+    return results
+};
diff --git a/javascript/572-Subtree-of-Another-Tree.js b/javascript/572-Subtree-of-Another-Tree.js
new file mode 100644
index 000000000..1820a9534
--- /dev/null
+++ b/javascript/572-Subtree-of-Another-Tree.js
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} subRoot
+ * @return {boolean}
+ */
+var isSubtree = function(root, subRoot) {
+    
+    // given two nodes are they the same?
+    const isSame = (n1, n2) => {
+        if (!n1 && !n2) return true;
+        if (!n1 || !n2 || n1.val !== n2.val) return false;
+        return isSame(n1.left, n2.left) && isSame(n1.right, n2.right);
+    }
+    
+    // check if subRoot is subtree of root:
+    const DFS = (node) => {
+        if (!node) return false;
+        if (isSame(node, subRoot)) return true;
+        return DFS(node.left) || DFS(node.right);
+    }
+    
+    
+    return DFS(root);
+    
+    
+};
diff --git a/javascript/70-Climbing-Stairs.js b/javascript/70-Climbing-Stairs.js
new file mode 100644
index 000000000..2d02c4faf
--- /dev/null
+++ b/javascript/70-Climbing-Stairs.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var climbStairs = function(n) {
+    const memoized = climb();
+    return memoized(n);
+};
+
+function climb() {
+    let cache = {};
+    
+    return function climbStairs(n) {
+        if (n in cache) {
+            return cache[n];
+        } else if (n >= 1 && n < 4) {
+            return n;
+        } else {
+            cache[n] = climbStairs(n-2) + climbStairs(n-1);
+            return cache[n];
+        }
+    }
+}
diff --git a/javascript/73-Set-Matrix-Zeroes.js b/javascript/73-Set-Matrix-Zeroes.js
new file mode 100644
index 000000000..36068902c
--- /dev/null
+++ b/javascript/73-Set-Matrix-Zeroes.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[][]} matrix
+ * @return {void} Do not return anything, modify matrix in-place instead.
+ */
+var setZeroes = function(matrix) {
+    let row = new Array(matrix.length);
+    let col = new Array(matrix[0].length);
+    
+    for (let i = 0; i < row.length; i++) {
+        for (let j = 0; j < col.length; j++) {
+            if (matrix[i][j] === 0) {
+                row[i] = 0;
+                col[j] = 0;
+            }
+        }
+    }
+    
+    for (let i = 0; i < row.length; i++) {
+        for (let j = 0; j < col.length; j++) {
+            if (row[i] == 0 || col[j] == 0) {
+                matrix[i][j] = 0;
+            }
+        }
+    }
+    
+};
diff --git a/javascript/98-Validate-Binary-Search-Tree.js b/javascript/98-Validate-Binary-Search-Tree.js
new file mode 100644
index 000000000..3d7cad0de
--- /dev/null
+++ b/javascript/98-Validate-Binary-Search-Tree.js
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+
+
+var isValidBST = function(root) {
+    return validate(root, null, null);
+};
+
+function validate(root, max, min) {
+    if (!root) {
+        return true;
+        } else if (max !== null && root.val >= max || min !== null && root.val <= min) {
+        return false;
+    } else
+        return validate(root.left, root.val, min) && validate(root.right, max, root.val);
+}