每日题单 · 2026-09-21

用法

每题先自己写 25 分钟（时间盒），卡住就找我要档位提示；做完把 [x] 勾上。 复盘题不写新笔记，直接在原文出处下方追加「二刷日期 + 一句话卡点」。

🆕 新题（codetop 前端岗频率榜）

题目	难度	频率	状态
15. 三数之和	中等	36	🔁（已刷过，重做）
141. 环形链表	简单	33	🔁（已刷过，重做）

🔁 复盘（vault 轮换池）

题目	难度	频率	备注
分割等和子集	中等	1	复盘 · 出处：GRD 动态规划
不同路径	中等	13	复盘 · 出处：GRD 动态规划

完成打卡

• 新题 1：15. 三数之和

/**
 * 排序 + 对撞双指针 / 边界剪枝与三向去重
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function (nums) {
    let res = []
    nums.sort((a, b) => a - b)
    let len = nums.length
 
    for (let i = 0; i < len-2; i++) {
        if(nums[i]>0) break
        if(i>0 &&nums[i] ===nums[i-1]) continue
 
        let left = i + 1, right = len - 1
 
        while (left < right) {
            let count = nums[i] + nums[left] + nums[right]
            if (count === 0) {
                res.push([nums[i], nums[left], nums[right]])
                while(left < right && nums[left] === nums[left+1]) left++
                while(left < right && nums[right] === nums[right-1]) right--
                left++
                right--
            } else if(count > 0) {
                right--
            } else {
                left++
            }
 
        }
    }
 
    return res
};

• 新题 2：141. 环形链表

/**
 * 快慢指针（Floyd 判圈算法）/ 可选链精炼边界
 * @param {ListNode} head
 * @return {boolean}
 */
var hasCycle = function(head) {
    let fast = head, slow = head
    while(fast?.next) {
        fast = fast.next.next
        slow = slow.next
        if(slow === fast) {
            return true
        }
    }
    return false
};

• 复盘 1：416. 分割等和子集

/**
 * 0-1 背包模型 / 一维布尔数组逆序滚动
 * @param {number[]} nums
 * @return {boolean}
 */
var canPartition = function(nums) {
    const sum = nums.reduce((a, b) => a+b, 0)
    if(sum % 2 !== 0) {
        return false
    }
    const target = sum / 2
    const dp = new Array(target + 1).fill(false)
    dp[0] = true
 
    for(const num of nums){
        for(let i = target; i >= num; i--) {
            dp[i] = dp[i] || dp[i-num]
        }
    }
 
    return dp[target]
};

• 复盘 2：62. 不同路径

/**
 * 网格 DP / 一维数组滚动优化
 * @param {number} m
 * @param {number} n
 * @return {number}
 */
var uniquePaths = function (m, n) {
    const dp = new Array(n).fill(1)
    for(let i = 1; i < m; i++) {
        for(let j = 1; j< n; j++) {
            dp[j] += dp[j-1]
        }
    }
    return dp[n-1]
};