leetcode刷题记录本

1. 两数之和

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
let twoSum = (nums, target) => {
    let targetMap = new Map()
    for (let i = 0; i < nums.length; i++) {
      const key = target - nums[i]
      if (targetMap.has(key)) {
        return [targetMap.get(key), i]
      }
      targetMap.set(nums[i], i)
}

2. 两数相加

/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var addTwoNumbers = function (l1, l2) {
    // 初始化一个新的链表，并设置进位的值为 0
    let head = new ListNode(0);
    let carry = 0;

    // 初始化一个指针，用于遍历新的链表
    let curr = head;

    // 循环遍历两个链表中的节点
    while (l1 || l2) {
        // 获取当前遍历到的两个链表的节点的值
        let x = (l1) ? l1.val : 0;
        let y = (l2) ? l2.val : 0;

        // 计算两个节点的值的和，并加上进位的值
        let sum = x + y + carry;

        // 更新进位的值
        carry = (sum >= 10) ? 1 : 0;

        // 将相加的结果存储到新链表中，并将指针向后移动
        curr.next = new ListNode(sum % 10);
        curr = curr.next;

        // 如果两个链表还有剩余的节点，则继续遍历
        if (l1) l1 = l1.next;
        if (l2) l2 = l2.next;
    }
    // 如果在上一步中有剩余的进位值，则将进位值存储到新链表中
    if (carry > 0) {
        curr.next = new ListNode(carry);
    }

    // 返回相加的结果
    return head.next;
};

3. 无重复字符的最长子串

/**
 * @param {string} s
 * @return {number}
 */
 var lengthOfLongestSubstring = function(s) {
  let res = []
  let max = 0
  for (let str of s) {
    while (res.includes(str)) {
      res.shift()
    }
    res.push(str)
    max = Math.max(max,res.length)
  }
  return max
};

4. 寻找两个正序数组的中位数

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number}
 */
var findMedianSortedArrays = function(nums1, nums2) {
    let result = []
    result = nums1.concat(nums2)
    if(result.length == 1){
        return result[0]
    }
    result.sort((a,b) => a-b)
    if( result.length%2 != 0){
        return result[Math.floor(result.length/2)]
    }
    else{
        return (result[result.length/2]+result[result.length/2-1])/2
    }
}

5. 最长回文子串

/**
 * @param {string} s
 * @return {string}
 */
var longestPalindrome = function(s) {
        if (s.length<2){
            return s
        }
        let res = ''
        for (let i = 0; i < s.length; i++) {
            // 回文子串长度是奇数
            helper(i, i)
            // 回文子串长度是偶数
            helper(i, i + 1) 
        }

        function helper(m, n) {
            while (m >= 0 && n < s.length && s[m] == s[n]) {
                m--
                n++
            }
            // 注意此处m,n的值循环完后  是恰好不满足循环条件的时刻
            // 此时m到n的距离为n-m+1，但是mn两个边界不能取 所以应该取m+1到n-1的区间  长度是n-m-1
            if (n - m - 1 > res.length) {
                // slice也要取[m+1,n-1]这个区间 
                res = s.slice(m + 1, n)
            }
        }
        return res
};