feat: update 4 leetcode

Author: kyriejoshua

leetcode/167.two-sum-ii-input-array-is-sorted.js

@@ -0,0 +1,60 @@
+/*
+ * @lc app=leetcode id=167 lang=javascript
+ *
+ * [167] Two Sum II - Input array is sorted
+ */
+
+// @lc code=start
+/**
+ * 最初考虑使用冒泡，但是时间复杂度太高
+ * 后续使用双指针解决
+ * 也可以使用二分法
+ * 下面是二分法的解决，时间复杂度 O(nlogn)
+ * @param {number[]} numbers
+ * @param {number} target
+ * @return {number[]}
+ */
+var twoSum = function(numbers, target) {
+ for (let i = 0; i < numbers.length; i++) {
+ let low = i + 1;
+ let high = numbers.length - 1;
+
+ while (low <= high) {
+ // 这里记得取得整数
+ let mid = ~~((high - low) / 2 + low);
+ if (numbers[i] + numbers[mid] === target) {
+ return [i + 1, mid + 1];
+ } else if (numbers[i] + numbers[mid] > target) {
+ high = mid - 1;
+ } else {
+ low = mid + 1;
+ }
+ }
+ }
+ return [1, numbers.length];
+};
+
+/**
+ * 双指针的写法
+ * 时间复杂度 O(n)
+ * @param {*} numbers
+ * @param {*} target
+ * @returns
+ */
+var twoSum2 = function(numbers, target) {
+ let i = 0;
+ let j = numbers.length - 1;
+
+ // 因为是一定有解，所以可以这样设置条件
+ while (numbers[i] + numbers[j] !== target) {
+ // 如果总和超过则右指针左移，如果总和少于则左指针右移
+ if (numbers[i] + numbers[j] > target) {
+ j--;
+ } else {
+ i++;
+ }
+ }
+
+ return [i + 1, j + 1];
+};
+// @lc code=end

leetcode/2.add-two-numbers.js

@@ -0,0 +1,89 @@
+/*
+ * @lc app=leetcode id=2 lang=javascript
+ *
+ * [2] Add Two Numbers
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers = function(l1, l2) {
+ let ans = new ListNode(-1);
+ let cur = ans;
+ let carry = 0;
+
+ while (l1 || l2) {
+ const val1 = l1 && l1.val || 0; // 注意保留默认值
+ const val2 = l2 && l2.val || 0; // 注意保留默认值
+ const sum = val1 + val2 + carry;
+ cur.next = new ListNode(sum % 10);
+ cur = cur.next;
+ // 当前和触发了进位，或者之前的进位仍然向前进
+ // carry = val1 + val2 > 9 || (val1 + val2 === 9 && carry);
+ // 下面这个方式的判断更加简洁
+ carry = Math.floor(sum / 10);
+
+ l1 = l1 ? l1.next : l1;
+ l2 = l2 ? l2.next : l2;
+ }
+
+ // 如果全部加完还有进位的话
+ if (carry) {
+ cur.next = new ListNode(1);
+ }
+
+ return ans.next;
+};
+
+/**
+ * 将链表值转化成字符串，再转成数字相加，但问题是过大的数字会转成科学记数法
+ * 因为这个问题 所以需要使用 BigInt
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+var addTwoNumbers2 = function(l1, l2) {
+ let l1Copy = l1;
+ let l2Copy = l2;
+ let str1 = str2 = '';
+
+ // 保存正确顺序的字符串
+ while (l1Copy) {
+ str1 = l1Copy.val + str1;
+ l1Copy = l1Copy.next;
+ }
+
+ while (l2Copy) {
+ str2 = l2Copy.val + str2;
+ l2Copy = l2Copy.next;
+ }
+
+ // 这里注意使用 BigInt 来避免生成科学计数法
+ // BigInt 接受字符串作为参数
+ let str = (BigInt(str1) + BigInt(str2)).toString();
+ let res = str.split('').reverse();
+ let i = 0;
+ let ans = new ListNode(-1);
+ let pre = ans;
+
+ // 当链表过长也就是产生的值过大时，这个方案会出错
+ while (i < res.length) {
+ pre.next = new ListNode(+res[i]);
+ pre = pre.next;
+ i++;
+ }
+
+ return ans.next;
+};
+
+// @lc code=end

leetcode/3.longest-substring-without-repeating-characters.js

@@ -0,0 +1,36 @@
+/*
+ * @lc app=leetcode id=3 lang=javascript
+ *
+ * [3] Longest Substring Without Repeating Characters
+ */
+
+// @lc code=start
+/**
+ * 动态规划？
+ * 滑动窗口，每往右一格，重新判断一次
+ * 逻辑类似判断子数组
+ * @param {string} s
+ * @return {number}
+ */
+var lengthOfLongestSubstring = function(s) {
+ if (!s) {
+ return 0;
+ }
+ // 保存当前最长的字符串
+ let str = '';
+ let maxLength = Number.MIN_SAFE_INTEGER;
+
+ for (const cur of s) {
+ const index = str.indexOf(cur);
+ // 动态改变当前最长的字符串
+ if (index !== -1) {
+ str = str.slice(index + 1);
+ }
+ str += cur;
+ // 保存更大长度值
+ maxLength = Math.max(maxLength, str.length);
+ }
+
+ return maxLength;
+};
+// @lc code=end

leetcode/61.rotate-list.js

@@ -0,0 +1,56 @@
+/*
+ * @lc app=leetcode id=61 lang=javascript
+ *
+ * [61] Rotate List
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ * this.val = (val===undefined ? 0 : val)
+ * this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * 时间复杂度：O(n), 最坏情况下，我们需要遍历该链表两次。
+ * 空间复杂度：O(1)，我们只需要常数的空间存储若干变量。
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+var rotateRight = function(head, k) {
+ if (k === 0 || head === null || head.next === null) {
+ return head;
+ }
+ // 用于保存链表的长度 从 1 开始
+ let n = 1;
+ let cur = head;
+
+ // 计算长度同时链表到最后一位
+ while (cur.next) {
+ cur = cur.next;
+ n++;
+ }
+
+ let left = n - k % n;
+ // 假如要移动的数字正好是链表长度的倍数，则无需移动
+ if (left === n) {
+ return head;
+ }
+
+ // 将链表形成环
+ cur.next = head;
+
+ while (left) {
+ cur = cur.next;
+ left--;
+ }
+
+ const ans = cur.next;
+ // 断开环
+ cur.next = null;
+
+ return ans;
+};
+// @lc code=end