finish 0053

README.md

@@ -28,7 +28,7 @@ since 2021.10.10 / Benben
 - 0027.Remove Element
 - 0028.Implement strStr()
 - 0035.Search Insert Position
-- 0053.Maximum SubArray (FIXME)
+- 0053.Maximum SubArray
 - 0104.Maximum Depth of Binary Tree
 - 0111.Minimum Depth of Binary Tree
 - 0144.Binary Tree PreOrder Traversal

interview/50/01-searchInsertionPosition.js

@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var searchInsert = function(nums, target) {
+  let left = 0
+  let right = nums.length - 1
+  let mid = 0
+
+  if (target <= nums[left]) return 0
+  if (target > nums[right]) return nums.length
+  if (target === nums[right]) return nums.length - 1
+
+  while (left <= right) {
+    mid = Math.floor((left + right) / 2)
+
+    if (target === nums[mid]) return mid
+
+    if (target > nums[mid]) {
+      left = mid + 1
+    } else {
+      right = mid - 1
+    }
+  }
+  if (target > nums[mid] && target < nums[mid + 1]) return mid + 1
+  return mid
+};
+
+
+// leetcode 0035

interview/50/02-reverseBetween.js

@@ -0,0 +1,38 @@
+/**
+ * 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} left
+ * @param {number} right
+ * @return {ListNode}
+ */
+var reverseBetween = function(head, left, right) {
+  let successor = null
+
+  const reverseN = (head, n) => {
+    if (n === 1) {
+      successor = head.next
+      return head
+    }
+    const last = reverseN(head.next, n - 1)
+    head.next.next = head
+    head.next = successor
+    return last
+  }
+
+  const doReverse = (head, left, right) => {
+    if (left === 1) {
+      return reverseN(head, right)
+    }
+    head.next = doReverse(head.next, left - 1, right - 1)
+    return head
+  }
+  return doReverse(head, left, right)
+};
+
+// leetcode 0092

interview/50/03-diameterOfBinaryTree.js

@@ -0,0 +1,31 @@
+/**
+ * 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 diameterOfBinaryTree = function(root) {
+  let maxDiameter = 0
+
+  const traverse = (root) => {
+    if (!root) return 0
+
+    let leftLength = traverse(root.left)
+    let rightLength = traverse(root.right)
+
+    maxDiameter = Math.max(maxDiameter, leftLength + rightLength)
+
+    return 1 + Math.max(leftLength, rightLength)
+  }
+  traverse(root)
+
+  return maxDiameter
+};
+
+// leetcode 0543

interview/50/04-mergeKSortedLists.js

@@ -0,0 +1,2 @@
+
+// leetcode 0023

interview/50/05-removeZeroSumConsecutiveNodesFromLinkedList.js

@@ -0,0 +1,2 @@
+
+// leetcode 1171

interview/50/06-maximumSubarray.js

@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSubArray = function(nums) {
+  if (nums.length === 0) return nums
+
+  let cur = nums[0]
+  let curMax = 0
+  let res = cur
+
+  for (let i = 1; i < nums.length; i++) {
+    curMax = Math.max(nums[i], cur + nums[i])
+    cur = curMax
+    res = Math.max(res, curMax)
+  }
+
+  return res
+}
+
+// leetcode 0053

leetcode-easy/0035-search-insert-position.js

@@ -7,16 +7,16 @@ var searchInsert = function(nums, target) {
   let left = 0
   let right = nums.length - 1
   let mid = 0
-  
+
   if (target <= nums[left]) return 0
   if (target > nums[right]) return nums.length
   if (target === nums[right]) return nums.length - 1
-  
+
   while (left <= right) {
     mid = Math.floor((left + right) / 2)
-    
+
     if (target === nums[mid]) return mid
-    
+
     if (target > nums[mid]) {
       left = mid + 1
     } else {

leetcode-easy/0053-maximum-subarray.js

@@ -3,30 +3,21 @@
  * @return {number}
  */
 var maxSubArray = function(nums) {
-  const { length } = nums
-  if (length === 1) return nums[0]
-
-  const resultArr = []
-  for (let i = 1; i < length + 1; i++) {
-    resultArr.push(maxSum(nums, i))
-  }
-  return Math.max(...resultArr)
-};
+  if (nums.length === 0) return nums
 
-const maxSum = (nums, size) => {
-  let maxValue = 0
-  for (let i = 0; i < size; i++) {
-    maxValue += nums[i]
-  }
+  let cur = nums[0]
+  let curMax = 0
+  let res = cur
 
-  let tempValue = maxValue
-  for (let j = size; j < nums.length; j++) {
-    tempValue = tempValue + nums[j] - nums[j - size]
-    if (tempValue > maxValue) {
-      maxValue = tempValue
-    }
+  for (let i = 1; i < nums.length; i++) {
+    curMax = Math.max(nums[i], cur + nums[i])
+    cur = curMax
+    res = Math.max(res, curMax)
   }
-  return maxValue
-}
 
-// TO FIX
+  return res
+};
+
+// 2022/05/09 done.
+// Runtime: 109 ms, faster than 48.46% of JavaScript online submissions for Maximum Subarray.
+// Memory Usage: 50.4 MB, less than 48.90% of JavaScript online submissions for Maximum Subarray.