feat: 🎸 update leetcode

Author: careteenL

src/algorithm/recursion/dfs-bfs.js

@@ -1,79 +1,86 @@
 /**
  * @desc 构造节点
- * @param {Any} key 
+ * @param {Any} key
  */
-function Node (key) {
-  this.children = []
-  this.key = key
+function Node(key) {
+  this.children = [];
+  this.key = key;
 }
 
 // 生成树结构
-const n1 = new Node('1')
-const n2 = new Node('2')
-const n3 = new Node('3')
-const n4 = new Node('4')
-const n5 = new Node('5')
-const n6 = new Node('6')
+const n1 = new Node("1");
+const n2 = new Node("2");
+const n3 = new Node("3");
+const n4 = new Node("4");
+const n5 = new Node("5");
+const n6 = new Node("6");
 
-n1.children.push(n2)
-n1.children.push(n5)
-n2.children.push(n3)
-n2.children.push(n4)
-n5.children.push(n6)
+n1.children.push(n2);
+n1.children.push(n5);
+n2.children.push(n3);
+n2.children.push(n4);
+n5.children.push(n6);
+
+//              1
+//          2       5
+//      3     4   6
 
 /**
  * @desc dfs 深度优先搜索
- * @param {Node} node 
+ * @param {Node} node
  */
-function dfs (node) {
-  const stack = [node]
-  let ret = []
+function dfs(node) {
+  const stack = [node];
+  let ret = [];
   while (stack.length > 0) {
-    const first = stack.shift()
-    ret.push(first.key)
-    first.children.slice().reverse().forEach(child => stack.unshift(child))
+    const first = stack.shift();
+    ret.push(first.key);
+    first.children
+      .slice()
+      .reverse()
+      .forEach((child) => stack.unshift(child));
   }
-  return ret
+  return ret;
 }
 // Test
-console.log('dfs: ', dfs(n1))
+console.log("dfs: ", dfs(n1));
 
 /**
  * @desc dfs 深度优先搜索 - 递归实现
- * @param {Node} node 
+ * @param {Node} node
  */
-function dfsRecursion (node) {
-  let ret = []
-  _dfsRecursion(node, ret)
-  return ret
+function dfsRecursion(node) {
+  let ret = [];
+  _dfsRecursion(node, ret);
+  return ret;
 }
 
-function _dfsRecursion (node, ret) {
-  ret.push(node.key)
-  node.children.forEach(child => _dfsRecursion(child, ret))
+function _dfsRecursion(node, ret) {
+  ret.push(node.key);
+  node.children.forEach((child) => _dfsRecursion(child, ret));
 }
 // Test
-console.log('dfsRecursion: ', dfsRecursion(n1))
+console.log("dfsRecursion: ", dfsRecursion(n1));
 
 /**
  * @desc dfs 深度优先搜索
- * @param {Node} node 
+ * @param {Node} node
  */
-function bfs (node) {
-  const queue = [node]
-  let ret = []
+function bfs(node) {
+  const queue = [node];
+  let ret = [];
   while (queue.length > 0) {
-    const first = queue.shift()
-    ret.push(first.key)
-    first.children.forEach(child => queue.push(child))
+    const first = queue.shift();
+    ret.push(first.key);
+    first.children.forEach((child) => queue.push(child));
   }
-  return ret
+  return ret;
 }
 // Test
-console.log('bfs: ', bfs(n1))
+console.log("bfs: ", bfs(n1));
 
-export {
-  dfs,
-  dfsRecursion,
-  bfs
-}
+// export {
+//   dfs,
+//   dfsRecursion,
+//   bfs
+// }

src/leetcode/003-longest-substring-without-reapting-characters.js

@@ -26,3 +26,48 @@ function lengthOfLongestSubstring(s) {
 console.log(lengthOfLongestSubstring("abcabcbb"));
 console.log(lengthOfLongestSubstring("bbbbb"));
 console.log(lengthOfLongestSubstring("pwwkew"));
+
+// 重新再写一遍
+// 找到一个字符串中最长的不重复子串的长度
+function lengthOfLongestSubstringNew(s) {
+  const set = new Set();
+  const len = s.length;
+  let rightKey = -1;
+  let result = 0;
+  for (let i = 0; i < len; i++) {
+    if (i !== 0) {
+      set.delete(s[i - 1]);
+    }
+    while (rightKey + 1 < len && !set.has(s[rightKey + 1])) {
+      set.add(s[rightKey + 1]);
+      rightKey++;
+    }
+    result = Math.max(result, rightKey - i + 1);
+  }
+  return result;
+}
+
+console.log(lengthOfLongestSubstringNew("abcabcbb")); // abc
+console.log(lengthOfLongestSubstringNew("bbbbb"));
+console.log(lengthOfLongestSubstringNew("pwwkew"));
+
+function lengthOfLongestSubstringNew1(s) {
+  let result = 0;
+  const len = s.length;
+  const set = new Set();
+  let left = 0;
+  for (let right = 0; right < len; right++) {
+    const value = s[right];
+    while (set.has(value)) {
+      set.delete(s[left++]);
+    }
+    set.add(value);
+    console.log("set: ", set);
+    result = Math.max(result, right - left + 1);
+  }
+  return result;
+}
+
+console.log(lengthOfLongestSubstringNew1("abcbacbb"));
+console.log(lengthOfLongestSubstringNew1("bbbbb"));
+console.log(lengthOfLongestSubstringNew1("pwwkew"));

src/leetcode/019-remove-nth-node-from-end-of-list.js

@@ -0,0 +1,74 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @desc 59. 删除链表的倒数第 N 个结点
+ * @leetcode https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/
+ * @param {ListNode} head
+ * @param {number} n
+ * @return {ListNode}
+ */
+var removeNthFromEndError = function (head, n) {
+  let current = head;
+  let layer = 0;
+  while (current) {
+    layer++;
+    current = current.next;
+  }
+  let _current = head;
+  const nLayer = layer - n;
+  let _layer = 0;
+  while (_current) {
+    if (_layer === nLayer) {
+      if (_current.next) {
+        _current.val = _current.next.val;
+        _current.next = _current.next.next;
+      } else {
+        _current = null;
+      }
+      // break;
+    }
+    _layer++;
+    _current = _current.next;
+  }
+  return head;
+};
+
+// 两个指针，找到需要删除的前一个节点，然后直接将 next 指向下下个即可
+var removeNthFromEnd = function (head, n) {
+  const dummyNode = ListNode(-1, head);
+  let left = dummyNode;
+  let right = dummyNode;
+  while (n--) {
+    right = right.next;
+  }
+  while (right.next) {
+    right = right.next;
+    left = left.next;
+  }
+  left.next = left.next.next;
+  return dummyNode.next;
+};
+
+function ListNode(val, next) {
+  this.val = val === undefined ? 0 : val;
+  this.next = next === undefined ? null : next;
+}
+
+const node1 = new ListNode(1);
+const node2 = new ListNode(2);
+const node3 = new ListNode(3);
+const node4 = new ListNode(4);
+const node5 = new ListNode(5);
+node1.next = node2;
+node2.next = node3;
+node3.next = node4;
+node4.next = node5;
+
+// 1 2 3 4 5
+// 1 2 3 5
+console.log(removeNthFromEnd(node1, 2));

src/leetcode/028-implement-strstr.js

@@ -8,23 +8,26 @@
  */
 // 方法一
 var strStr = function (haystack, needle) {
-  return haystack.indexOf(needle)
-}
+  return haystack.indexOf(needle);
+};
 // Test
-console.log(strStr('hello', 'll'))
-console.log(strStr('aaaaa', 'bba'))
+console.log(strStr("hello", "ll"));
+console.log(strStr("aaaaa", "bba"));
 
 // 方法二
 var strStr2 = function (haystack, needle) {
   for (let i = 0; i < haystack.length; i++) {
     if (haystack[i] === needle[0]) {
       if (haystack.substr(i, needle.length) === needle) {
-        return i
+        return i;
       }
     }
   }
-  return -1
-}
+  return -1;
+};
 // Test
-console.log(strStr2('hello', 'll'))
-console.log(strStr2('aaaaa', 'bba'))
+console.log(strStr2("hello", "ll"));
+console.log(strStr2("aaaaa", "bba"));
+
+// 方法三 KMP 实现
+// 代码随想录 视频讲解 https://www.bilibili.com/video/BV1M5411j7Xx?vd_source=a0beb1b1b69021ba06490959315cf7ef&spm_id_from=333.788.videopod.sections

src/leetcode/056-merge-intervals.js

@@ -0,0 +1,32 @@
+/**
+ * @desc 56. 合并区间
+ * @leetcode https://leetcode.cn/problems/merge-intervals/description/
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+var merge = function (intervals) {
+  intervals = intervals.sort((a, b) => a[0] - b[0]);
+  let answer = [];
+  for (let value of intervals) {
+    const last = answer.length - 1;
+    // 可以合并的条件
+    if (answer.length && value[0] <= answer[last][1]) {
+      answer[last][1] = Math.max(answer[last][1], value[1]);
+    } else {
+      answer.push(value);
+    }
+  }
+  return answer;
+};
+
+// 先根据每一项左区间做排序
+// 遍历
+// [[1,3]]
+console.log(
+  merge([
+    [15, 18],
+    [1, 3],
+    [8, 10],
+    [2, 6],
+  ])
+);