前言

本五前端，普通本科，找不到工作，投了一个多星期了只有一个面试，心灰意冷，已经失业三个月了，太焦虑了，没办法，只能刷刷力扣，看看有什么机会吧。主技术栈是Vue、React也有项目经验，广州深圳求内推

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

function lengthOfLongestSubstring(s: string): number {
    // 双指针滑动窗口
    let l = 0
    let r = 0
    let set = new Set<string>()
    let max = 0
    for(r;r < s.length;r++){
        if(!set.has(s[r])){
            set.add(s[r])
            max = Math.max(max,set.size)
        }else{
            while(set.has(s[r])){
                set.delete(s[l++])
            }
            set.add(s[r])
        }
    }
    return max
};

2/100 88. 合并两个有序数组

//  非递减顺序就是递增顺序（从后往前）
function merge(nums1: number[], m: number, nums2: number[], n: number): void {
    let tail = m + n - 1
    let p1 = m - 1
    let p2 = n - 1
    let cur
    while(p1 > -1 || p2 > -1){
        if(p1 === -1){
            cur = nums2[p2--]
        }else if(p2 === -1){
            cur = nums1[p1--]
        }else if(nums1[p1] > nums2[p2]){
            cur = nums1[p1--]
        }else {
            cur = nums2[p2--]
        }
        nums1[tail--] = cur
    }
};   

3/100 165. 比较版本号

function compareVersion(version1: string, version2: string): number {
    let arr1 = version1.split('.')
    let arr2 = version2.split('.')
    let max = Math.max(arr1.length,arr2.length)
    for(let i = 0; i < max;i++){
        let item1 = arr1[i] ? +arr1[i] : 0
        let item2 = arr2[i] ? +arr2[i] : 0
        if(item1 > item2){
            return 1
        }else if(item1 < item2){
            return -1
        }
    }
    return 0
};

4/100 415. 字符串相加

function addStrings(num1: string, num2: string): string {
    let sum = 0
    let cur = 0
    let l1 = num1.length - 1
    let l2 = num2.length - 1
    let res = []
    while(l1 > -1 || l2 > -1){
        sum += cur
        cur = 0
        if(l1 > -1){
            sum += +num1[l1--]
        }
        if(l2 > -1){
            sum += +num2[l2--]
        }
        if(sum > 9){
            sum = sum % 10
            cur = 1
        }
        res.push(sum)
        sum = 0
    }
    if(cur === 1) res.push(1)
    return res.reverse().join('')
};

5/100 1. 两数之和

function twoSum(nums: number[], target: number): number[] {
    let map = new Map<number,number>()
    for(let i = 0;i < nums.length;i++){
        if(!map.has(target - nums[i])){
            map.set(nums[i],i)
        }else {
            return [i,map.get(target - nums[i])]
        }
    }
};

6/100 20. 有效的括号

function isValid(s: string): boolean {
    let map = new Map<string,string>([['(',')'],['{','}'],['[',']']])
    let res:string[] = []
    for(let i = 0;i < s.length;i++){
        if(map.has(s[i])){
            res.push(map.get(s[i]))
        }else{
            if(res[res.length - 1] === s[i]){
                res.pop()
            }else{
                return false
            }
        }
    }
    return res.length === 0
};

7/100 46. 全排列

function permute(nums: number[]): number[][] {
    let res: number[][] = []
    const dfs = (arr:number[]) => {
        if(arr.length === nums.length){
            res.push([...arr])
            return
        }
        for(let i = 0;i < nums.length;i++){
            if(!arr.includes(nums[i])){
                arr.push(nums[i])
                dfs(arr)
                arr.pop()
            }
        }
    }
    dfs([])
    return res
};

8/100 53. 最大子序和

function maxSubArray(nums: number[]): number {
    // 贪心算法
    let memo = [nums[0]]
    let max = nums[0]
    for(let i = 1;i < nums.length;i++){
        memo[i] = Math.max(nums[i] + memo[i - 1],nums[i])
        max = Math.max(memo[i],max)
    }
    return max
};

9/100 206. 反转链表

function reverseList(head: ListNode | null): ListNode | null {
    // 双指针
    let pre: ListNode | null = null
    let cur: ListNode | null = head
    while(cur){
        let next = cur.next
        cur.next = pre
        pre = cur
        cur = next
    }
    return pre
};

10/100 112. 路径总和

function hasPathSum(root: TreeNode | null, targetSum: number): boolean {
    if(!root) return false
    if(!root.left && !root.right) return targetSum === root.val
    return hasPathSum(root.left,targetSum - root.val) ||  hasPathSum(root.right,targetSum - root.val)
};