Update to own

Author: zangbianxuegu

0019. Remove Nth Node From End of List.js

@@ -0,0 +1,17 @@
+
+// Given a linked list, remove the n - th node from the end of list and return its head.
+
+// Example:
+
+// Given linked list: 1 -> 2 -> 3 -> 4 -> 5, and n = 2.
+
+// After removing the second node from the end, the linked list becomes 1 -> 2 -> 3 -> 5.
+// Note:
+
+// Given n will always be valid.
+
+// Follow up:
+
+// Could you do this in one pass ?
+
+

0083. Remove Duplicates from Sorted List.js

@@ -0,0 +1,39 @@
+// Given a sorted linked list, delete all duplicates such that each element appear only once.
+
+// Example 1:
+
+// Input: 1 -> 1 -> 2
+// Output: 1 -> 2
+
+// Example 2:
+
+// Input: 1 -> 1 -> 2 -> 3 -> 3
+// Output: 1 -> 2 -> 3
+
+
+// 1) 
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const deleteDuplicates = function (head) {
+  let current = head
+  while (current) {
+    if (current.next && current.val === current.next.val) {
+      current.next = current.next.next
+    } else {
+      current = current.next
+    }
+  }
+  return head
+}
+// Runtime: 64 ms, faster than 81.24 % of JavaScript online submissions for Remove Duplicates from Sorted List.
+// Memory Usage: 36 MB, less than 25.00 % of JavaScript online submissions for Remove Duplicates from Sorted List.
+

0118. Pascal's Triangle.js

@@ -0,0 +1,43 @@
+// Given a non - negative integer numRows, generate the first numRows of Pascal's triangle.
+
+// In Pascal's triangle, each number is the sum of the two numbers directly above it.
+
+// Example:
+
+// Input: 5
+// Output:
+// [
+//   [1],
+//   [1, 1],
+//   [1, 2, 1],
+//   [1, 3, 3, 1],
+//   [1, 4, 6, 4, 1]
+// ]
+
+
+// 1) 
+/**
+ * @param {number} numRows
+ * @return {number[][]}
+ */
+const generate = (numRows) => {
+  let res = []
+  for (let i = 0; i < numRows; i++) {
+    if (i === 0) {
+      res.push([1])
+    } else {
+      let row = []
+      for (let j = 0; j <= res[i - 1].length; j++) {
+        if (j === 0 || j === res[i - 1].length) {
+          row.push(1)
+        } else {
+          row.push(res[i - 1][j - 1] + res[i - 1][j])
+        }
+      }
+      res.push(row)
+    }
+  }
+  return res
+}
+// Runtime: 56 ms, faster than 49.72 % of JavaScript online submissions for Pascal's Triangle.
+// Memory Usage: 33.7 MB, less than 100.00 % of JavaScript online submissions for Pascal's Triangle.

0119. Pascal's Triangle II.js

@@ -0,0 +1,61 @@
+// Given a non - negative index k where k ≤ 33, return the kth index row of the Pascal's triangle.
+
+// Note that the row index starts from 0.
+
+// In Pascal's triangle, each number is the sum of the two numbers directly above it.
+
+// Example:
+
+// Input: 3
+// Output: [1, 3, 3, 1]
+// Follow up:
+
+// Could you optimize your algorithm to use only O(k) extra space ?
+
+
+// 1) 
+/**
+ * @param {number} rowIndex
+ * @return {number[]}
+ */
+const getRow = (rowIndex) => {
+  let res = [1]
+  if (rowIndex > 0) {
+    for (let i = 0; i < rowIndex; i++) {
+      let last = res
+      let len = last.length
+      res = []
+      for (let j = 0; j <= len; j++) {
+        if (j === 0 || j === len) {
+          res[j] = 1
+        } else {
+          res.push(last[j - 1] + last[j])
+        }
+      }
+    }
+  }
+  return res
+}
+// Runtime: 52 ms, faster than 82.87 % of JavaScript online submissions for Pascal's Triangle II.
+// Memory Usage: 33.8 MB, less than 70.00 % of JavaScript online submissions for Pascal's Triangle II.
+
+
+// 2) 更简洁、更少的空间
+/**
+ * @param {number} rowIndex
+ * @return {number[]}
+ */
+const getRow = (rowIndex) => {
+  let res = Array(rowIndex + 1).fill(0)
+  res[0] = 1
+  for (let i = 1; i < rowIndex + 1; i++) {
+    for (let j = i; j > 0; j--) {
+      res[j] += res[j - 1]
+    }
+  }
+  return res
+}
+// Runtime: 52 ms, faster than 82.87 % of JavaScript online submissions for Pascal's Triangle II.
+// Memory Usage: 33.8 MB, less than 70.00 % of JavaScript online submissions for Pascal's Triangle II.
+
+

0203. Remove Linked List Elements.js

@@ -0,0 +1,39 @@
+// Remove all elements from a linked list of integers that have value val.
+
+// Example:
+
+// Input: 1 -> 2 -> 6 -> 3 -> 4 -> 5 -> 6, val = 6
+// Output: 1 -> 2 -> 3 -> 4 -> 5
+
+
+// 1)
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} val
+ * @return {ListNode}
+ */
+const removeElements = (head, val) => {
+  let current = head
+  while (current) {
+    if (head.val === val) {
+      current = current.next
+      head = head.next
+    } else {
+      if (current.next && current.next.val === val) {
+        current.next = current.next.next
+      } else {
+        current = current.next
+      }
+    }
+  }
+  return head
+}
+// Runtime: 76 ms, faster than 53.38 % of JavaScript online submissions for Remove Linked List Elements.
+// Memory Usage: 37.6 MB, less than 25.00 % of JavaScript online submissions for Remove Linked List Elements.

0229. Majority Element II.js

@@ -13,7 +13,10 @@
 // Output: [1, 2]
 
 
-// 1) Map
+// 1) O(n^2)
+
+
+// 2) Map
 // 时间复杂度 O(n)，空间复杂度 O(n)
 /**
  * @param {number[]} nums
@@ -36,4 +39,49 @@ const majorityElement = (nums) => {
   return res
 }
 // Runtime: 68 ms, faster than 37.98% of JavaScript online submissions for Majority Element II.
-// Memory Usage: 37.3 MB, less than 14.29 % of JavaScript online submissions for Majority Element II.
+// Memory Usage: 37.3 MB, less than 14.29 % of JavaScript online submissions for Majority Element II.
+
+
+// 3) Boyer-Moore Vote algorithm
+// 时间复杂度 O(n)，空间复杂度 O(1)
+// similar to 0169
+// 大于 ⌊ n/3 ⌋，分析问题发现，最多出现两个符合条件的元素。设置两个候选。
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const majorityElement = (nums) => {
+  let candidate1 = -1
+  let candidate2 = -1
+  let count1 = 0
+  let count2 = 0
+  let res = []
+  for (num of nums) {
+    if (count1 === 0 && num !== candidate2) {
+      candidate1 = num
+    } else if (count2 === 0 && num !== candidate1) {
+      candidate2 = num
+    }
+    if (num === candidate1) {
+      count1++
+    } else if (num === candidate2) {
+      count2++
+    } else {
+      count1--
+      count2--
+    }
+  }
+  const counts = (arr, value) => {
+    return arr.reduce((a, v) =>
+      v === value ? a + 1 : a + 0, 0
+    )
+  }
+  for (let candidate of [candidate1, candidate2]) {
+    if (counts(nums, candidate) > nums.length / 3) {
+      res.push(candidate)
+    }
+  }
+  return res
+}
+// Runtime: 64 ms, faster than 55.37% of JavaScript online submissions for Majority Element II.
+// Memory Usage: 37 MB, less than 14.29 % of JavaScript online submissions for Majority Element II.