【力扣】刷题记录（语言JS）

前言

       以前刷的都是洛谷，最近开始系统刷力扣了，主要是熟悉一下JS语言，以前基本是C/Java来刷，顺便复习一下算法。.

      找的刷题顺序是这篇，个人感觉挺有用的，还有算法讲解之类的：   代码随想录 (programmercarl.com)https://programmercarl.com/

1.二分查找 

 基础题了，把区间搞清楚了基本也就出来了。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var search = function(nums, target) {
    var left=0, right=nums.length-1
    var mid=-1
    while(left<=right){
        mid=parseInt((left+right)/2)
        if(nums[mid]==target) return mid
        if(nums[mid]>target){
            right = mid-1
        }
        else if(nums[mid]<target){
            left= mid+1
        }
    }
    if (left>=right) return -1
};

2.移除元素 

空间复杂度要求为O(1)，就不能用暴力解法了。

第一想法是，设置两个指针，一头一尾，头往后走，遇到所指定元素就和尾换，这样把所有的指定元素都挪到尾去，直到头尾相遇。

/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
var removeElement = function(nums, val) {
    let i=0,j=nums.length-1
    while(nums[j]==val){
        j--
     }
    while(i<=j){
        if((nums[i]==val)){
           // if(i==j){break}
            nums[i]=nums[j]
            nums[j]=val
            i++
            while(nums[j]==val){
                j--
            }
        }
        else{
            i++
        }
    }
    console.log(i)
    return i
};

法二：快慢指针

//时间复杂度：O(n)
//空间复杂度：O(1)
var removeElement = (nums, val) => {
    let k = 0;
    for(let i = 0;i < nums.length;i++){
        if(nums[i] != val){
            nums[k++] = nums[i]
        }
    }
    return k;
};

3.有序数组的平方 

方法一：暴力排序，每个数平方完后再排序。

方法二：双指针法

 这个思路其实就是头指针和尾指针相比较，大的那个就填入新数组里。

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function(nums) {
    let i=0,j=nums.length-1,k=nums.length-1,a,b
    let ans = new Array(nums.length).fill(0)
    while(i<=j){
        a=nums[i]*nums[i]
        b=nums[j]*nums[j]
        if(a>=b){
            ans[k--]=a
            i++
        }
        else{
            ans[k--]=b
            j--
        }
    }
    return ans
};

4.长度最小的子数组 

var minSubArrayLen = function(target, nums) {
    let start, end
    start = end = 0
    let sum = 0
    let len = nums.length
    let ans = Infinity
    
    while(end < len){
        sum += nums[end];
        while (sum >= target) {
            ans = Math.min(ans, end - start + 1);
            sum -= nums[start];
            start++;
        }
        end++;
    }
    return ans === Infinity ? 0 : ans
};

暴力解法就不说了，还是双指针法，《随想录》里写的是滑动窗口，其实本质上也是一头一尾的指针，尾指针不断向前直到和大于等于target，此时再使头指针不断向前直到和小于target，不断重复，直到尾指针到达数组尾部。

5.螺旋矩阵II 

 

知识点

let a = new Array(5).fill({});

       表面上看似确实创建了一个用空对象填充的数组对象，然而实际上存在一个巨大的坑，因为我们是使用同一个空对象来填充（fill）数组的，这样就会造成数组中所有的对象都是连动的，从而改变一个会造成所有的都会改变（牵一发动全身），从而与我们初始的意愿所违背。综上所述，大家如果只是创建并初始化数组对象的值是基本数据类型的话，完全可以用这种方法没问题，如果是引用数据类型的就要注意了

        所以，可以

let m = 3,n = 4;
let arr = Array(m).fill().map(() => Array(n));
console.log(arr);  //output:[[empty × 4],[empty × 4],[empty × 4]]