前言

看到某脉上面总在讨论前端已死，真实情况是今年的金三银四肯定是行情没有前几年好，跳槽基本是涨幅很少或者是平薪或者是降薪的都有大把人在，因此很多人都基本上是有坑蹲着就先蹲着观望观望等行情变好了再换工作，而这也造成了大量公司的HC都不释放出来，挂着招聘实际上并没有再招人，而往往每年都会涌入一大把人转行学习前端，岗位变少，求职者变多，那么对应的招聘方肯定是会拉低整体的薪资水平，并且提高招聘要求，但不管怎么样，提升自己和润色自己的简历才是最重要的，就我个人来说简历修改的还算可以，基本上投递同行业或者跨行业基本上一投一个准

科普-算法复杂度

时间复杂度

时间复杂度-程序执行时所需要的计算量（CPU），大致可以分为以下几种

O(1)一次就够（数量级）
O(n)和传输的数据量一样（数量级）
O(n^2)数据量的平方（数量级）
O(logn)数据量的对数（数量级）
O(nlogn)数据量数据量的对数（数量级）

一个算法的时间复杂度最好控制在O(n)以下，最多不超过 O(nlogn)才算是一个好的算法，附上以下图做参考展示

常见的时间复杂度举例

O(1)

function (obj = {}) {
    // o(1)
    return obj.a + obj.b + obj.c
}

O(n)

function fn(arr = []) {
     // O(n)
     for(let i = 0; i < arr.length;i++) {
     }
}

O(n^2)

function fn(arr = []) {
     // O(n)
     for(let i = 0; i < arr.length;i++) {
          for(let j = 0; j < arr.length;j++) {
         }
     }
}

O(logn)

function fn(arr = []) {
     // O(logn)
    // 二分
}

O(nlogn)

function fn(arr = []) {
     // O(nlogn)
     for() {
     //二分
     }
}

空间复杂度

空间复杂度-程序执行时需要的内存空间

O（1）有限的、可数的空间（数量级）
O（n）和输入的数据量相同的空间（数量级）

常见的空间杂度举例

O(1)

function (arr = []) {
    // o(1)
    const a = arr[1]
    const b = arr[2]
}

O(n)

function fn(arr = []) {
     // O(n)
    const arr2 = []
    
    for (let i = 0;i < arr.length; i++) {
        arr2[2] = arr[i]
    }
}

题目：将一个数组旋转K步

思路一：把末尾的元素挨个pop，然后unshift到数组前面

时间复杂度O(n^2),空间复杂度O(1)

function rotate1(arr,k) {
    const length = arr.length
    if(!k || length === 0) return arr
    const step = Math.abs(k % length)
    for (let i = 0;i<step;i++) {
        const n = arr.pop()
        if(n !== null) {
            arr.unshift(n) // 数组是一个有序结构，unshift非常慢 时间复杂度为O(n)
        }
    }
    return arr
}

思路二：把数组拆分，最后concat拼接到一起3

时间复杂度O(1),空间复杂度O(n)

function rotate2(arr,k) {
    const length = arr.length
    if(!k || length === 0) return arr
    const step = Math.abs(k % length)
    const part1 = arr.slice(-step)
    const part2 = arr.slice(0,length - step)
    const part3 = part1.concat(part2)
    return part3
}

功能测试

const arr = [1,2,3,4,5,6,7]
const arr1 = rotate(arr,3)
console.log(arr1)

单元测试

describe('数组旋转'， ()=>{
    it('正常情况', () => {
        const arr = [1,2,3,4,5,6,7]
        const k = 3
        const res = totate(arr,k)
        expect(res).toEqual([5,6,7,1,2,3,4])
    })
    it('数组为空', () => {
        const res = totate([],3)
        expect(res).toEqual([])
    })
    it('k是负值', () => {
        const arr = [1,2,3,4,5,6,7]
        const k = -3
        const res = totate(arr,k)
        expect(res).toEqual([5,6,7,1,2,3,4])
    })
    it('k是0', () => {
        const arr = [1,2,3,4,5,6,7]
        const k = 0
        const res = totate(arr,k)
        expect(res).toEqual([1,2,3,4,5,6,7])
    })
})

js算法题-20230419

前言