前端算法学习记录（1）

1.了解时间复杂度和空间复杂度的区别，前端应该重时间，轻空间

2.学习把一个数组旋转k步的解题思路：

①使用for循环以及api的pop和unshift实现

前端重时间，轻空间
// 时间复杂度O(n^2)-----
// 空间复杂度(1)-----只有一个变量
function rotate(arr, k) {
    const length=arr.length
    const step=Math.abs(k)
    if(!k || length===0) return arr
    for(let i=0;i<step;i++){
        /*arr.pop是删除数组最后一个元素并返回，arr.unshift是把元素添加到数组的头部*/
       arr.unshift(arr.pop()) //数组是一个有序结构，unshift，shift，splice操作非常慢（破坏了数组结构，在时间上相当于遍历了）
    }
    return arr
}
// 功能测试
console.log(rotate([1,2,3,4,5,6,7],3))

//时间复杂度O(n^2) 空间复杂度O（1）

②使用slice和contact，先把数组slice成两个
ab数组，再用contact拼接，把b放在前面

// 时间复杂度O(1)----没有循环
// 空间复杂度O(n)----arr1+arr2=arr=n
function rotate2(arr,k){
    const length=arr.length
    const step=Math.abs(k)
    if(!k || length===0) return arr
    const arr1=arr.slice(-step)
    const arr2=arr.slice(0,length-step)
    const arr3=arr1.concat(arr2)
    return arr3
}

// 功能测试
console.log(rotate2([1,2,3,4,5,6,7],3)) 
//时间复杂度O(1) 空间复杂度O（n）  前端重时间，轻空间（所以这种方式比较好）

③根据规律找出算法（该方法有点投机取巧）
最终是方法②最适合，在前端可以牺牲空间来降低时间复杂度，当数组的大小越大时，cpu所需要的计算时间和方①的所需时间相差甚远。

性能测试：

const arr=[]
for(let i=0;i<10*10000;i++){
    arr.push(i)
}
console.time('rotate')
rotate(arr,9*10000)
console.timeEnd('rotate') //2468ms

const arr2=[]
for(let i=0;i<10*10000;i++){
    arr2.push(i)
}
console.time('rotate2')
rotate2(arr2,9*10000)
console.timeEnd('rotate2') //0.92ms

3.学习解决如何判断一个字符串的括号是否匹配的问题，可以通过栈的思想来解决

栈是先进后出的，栈和数组的区别在哪？其实栈是一种逻辑结构，而数组是一种物理结构，两者是没有可比性的。
由于栈是先进后出的，所以可以先声明两个字符串的那个是左括号和右括号，然后遍历数组，当某个字符是左括号时入栈，当遍历到右括号时，判断栈顶是否是对应右括号的左括号，如果是就出栈，否则该字符串的括号不是匹配成对的，最终判断栈的length是否为0，如果是0说明该字符串的括号是匹配的。

4.学习队列，两个栈实现一个队列（先进先出），这个忘记了，明天再看看