🔥 LeetCode 热题 HOT 100 JS版本

1. 两数之和

//map存储需要的值和索引，X为当前数值，查询是否存在target-X，是则返回，否则存入X。
var twoSum = function (nums, target) {
    let map = new Map();
    for (let i = 0; i < nums.length; i++) {
        if (map.has(nums[i])) {
            return [i, map.get(nums[i])]
        } else {
            map.set(target - nums[i], i)
        }
    }
    return []
};

2.两数相加

//取两个链表长度，短的末尾用0补全(对齐相加)，考虑进位。
var addTwoNumbers = function (l1, l2) {
    let newList = new ListNode(0);
    let p1 = l1, p2 = l2, cur = newList;
    let isExtra = 0;
    while (p1 || p2) {
        let val1 = p1 ? p1.val : 0
        let val2 = p2 ? p2.val : 0
        let val = (val1 + val2 + isExtra) % 10
        cur.next = new ListNode(val)
        isExtra = ((val1 + val2 + isExtra) / 10) >> 0
        p1 && (p1 = p1.next)
        p2 && (p2 = p2.next)
        cur = cur.next
    }
    if (isExtra > 0) {
        cur.next = new ListNode(isExtra)
    }
    return newList.next
};

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

//双指针创建滑动窗口，判断是否重复，重则left++，不重则right++
var lengthOfLongestSubstring = function (s) {
    if (s.length <= 1) return s.length;
    let left = 0, right = 1, temp = '', max = 0;
    while (right < s.length) {
        temp = s.slice(left, right)
        if (temp.indexOf(s[right]) > -1) {
            left++
            continue
        } else {
            right++
        }
        max = Math.max(max, right - left)
    }
    return max
};

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

//二分+分割线，创建一条分割线分割数组A、B，中位数取决于这条分割线两侧的数值
//对短数组进行二分,不断比较分割线交叉方向两组数的大小，调整段数组上的low和right指针
var findMedianSortedArrays = function (nums1, nums2) {
    nums1.length > nums2.length && ([nums1, nums2] = [nums2, nums1]);
    const m = nums1.length, n = nums2.length;
    let low = 0, high = m;
    while (low <= high) {
        const i = low + Math.floor((high - low) / 2),//数組A中minRightA的下标，分割线的位置
            j = Math.floor((m + n + 1) / 2) - i;//j:数組B中minRightB的下标，分割线的位置
        const maxLeftA = i === 0 ? -Infinity : nums1[i - 1],
            minRightA = i === m ? Infinity : nums1[i];
        const maxLeftB = j === 0 ? -Infinity : nums2[j - 1],
            minRightB = j === n ? Infinity : nums2[j];
        if (maxLeftA <= minRightB && maxLeftB <= minRightA) {
            return(m + n) & 1
                ? Math.max(maxLeftA, maxLeftB)
                : (Math.max(maxLeftA, maxLeftB) + Math.min(minRightA, minRightB)) / 2
        } else if (maxLeftA > minRightB) {
            high = i - 1
        } else {
            low = low + 1
        }
    }
};

5. 最长回文子串

//  1.暴力求解 O(n^3)
var isPalindromic = function (s) {
    let len = s.length;
    for (let i = 0; i < len / 2; i++) {
        if (s.charAt(i) != s.charAt(len - i - 1)) {
            return false;
        }
    }
    return true;
};
const longestPalindrome = (s) => {
    let max = 0, len = s.length, ans = '';
    for (let i = 0; i < len; i++) {
        for (let j = i + 1; j <= len; j++) {
            let test = s.substring(i, j);
            if (isPalindromic(test) && test.length > max) {
                ans = s.substring(i, j);
                max = Math.max(max, ans.length)
            }
        }
    }
    return ans;
}

// 2.中心扩散，寻找最长子串 O(n^2)
const longestPalindrome = (s) => {
    let res = ''
    for (let i = 0; i < s.length; i++) {
        const s1 = palindrome(s, i, i)//奇数回文串aba型
        const s2 = palindrome(s, i, i + 1)//奇数回文串abba型
        res = res.length <= s1.length ? s1 : res
        res = res.length <= s2.length ? s2 : res
    }
    return res
}
const palindrome = (s, l, r) => { //返回以l,r为中心扩散的最长回文子串
    while (l >= 0 && r < s.length && s[l] === s[r]) {
        l--;
        r++
    }
    return s.slice(l + 1, r)
}

// 3.动态规划
const longestPalindrome = (s) => {
    let n = s.length, res = '';
    let dp = Array.from(new Array(n), () => new Array(n).fill(0))
    // console.log(dp)
    for (let i = n - 1; i >= 0; i--) {
        for (let j = i; j < n; j++) {
            dp[i][j] = s[i] == s[j] && (j - i < 2 || dp[i + 1][j - 1])
            if (dp[i][j] && j - i + 1 > res.length) {
                res = s.substring(i, j + 1)
            }
        }
    }
    return res
}