✨ 20210601

Author: tangweikun

TODO.md

@@ -50,3 +50,9 @@
 - [ ] Add Discuss 31
 - [ ] 实现冒泡排序
 - [ ] 实现选择排序
+
+206
+3
+2
+5
+19

src/1-two-sum/20210601.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function (nums, target) {
+  const hash = {};
+
+  for (let i = 0; i < nums.length; i++) {
+    if (hash[nums[i]] !== undefined) {
+      return [hash[nums[i]], i];
+    }
+    hash[target - nums[i]] = i;
+  }
+};

src/19-remove-nth-node-from-end-of-list/index.js

@@ -0,0 +1,18 @@
+var removeNthFromEnd = function (head, n) {
+  let preHead = new ListNode(0);
+  preHead.next = head;
+  let fast = preHead;
+  let slow = preHead;
+
+  // 快先走 n+1 步
+  while (n--) {
+    fast = fast.next;
+  }
+  // fast、slow 一起前进
+  while (fast && fast.next) {
+    fast = fast.next;
+    slow = slow.next;
+  }
+  slow.next = slow.next.next;
+  return preHead.next;
+};

src/2-add-two-numbers/20210601.js

@@ -0,0 +1,31 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function (l1, l2) {
+  const pre = new ListNode();
+  let cur = pre;
+  let carry = 0;
+
+  while (l1 || l2) {
+    const sum = (l1 ? l1.val : 0) + (l2 ? l2.val : 0) + carry;
+    carry = sum >= 10 ? 1 : 0;
+    cur.next = new ListNode(sum % 10);
+    cur = cur.next;
+
+    l1 && (l1 = l1.next);
+    l2 && (l2 = l2.next);
+  }
+
+  carry && (cur.next = new ListNode(carry));
+
+  return pre.next;
+};

src/20-valid-parentheses/20210601.js

@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isValid = function (s) {
+  const hash = {
+    ')': '(',
+    ']': '[',
+    '}': '{',
+  };
+
+  const stack = [];
+  for (let i = 0; i < s.length; i++) {
+    const cur = stack.pop();
+    if (cur === undefined) {
+      stack.push(s[i]);
+      continue;
+    }
+    if (hash[s[i]] !== cur) {
+      stack.push(cur);
+      stack.push(s[i]);
+    }
+  }
+
+  return stack.length === 0;
+};

src/206-reverse-linked-list/index.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 [reverse, cur] = [null, head];
+
+  while (cur) {
+    const next = cur.next;
+    cur.next = reverse;
+    reverse = cur;
+    cur = next;
+  }
+
+  return reverse;
+};

src/3-longest-substring-without-repeating-characters/20210601.js

@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function (s) {
+  let res = 0;
+  let start = 0;
+  const map = new Map();
+
+  for (let i = 0; i < s.length; i++) {
+    if (map.has(s[i])) {
+      start = Math.max(start, map.get(s[i]));
+    }
+    res = Math.max(res, i - start + 1);
+    map.set(s[i], i + 1);
+  }
+
+  return res;
+};