neetcode-gh · neetcode-gh · Apr 4, 2022 · Apr 3, 2022 · Apr 3, 2022 · Apr 3, 2022
diff --git a/javascript/1-Two-Sum.js 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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;
+};