JS实现 LeetCode 数组类算法（三）

更多算法实现见：https://github.com/Erindcl/Daily-algorithm

268. 缺失数字

• 给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。

分析：将数组进行升序排序，没有缺失的数组元素应该与其下标相等，故排序后遍历数组，将数组下标与元素进行比较，若不相等，则数组下标即为该数组缺失的元素。若数组所有的元素都与其下标相等，则数组缺失的为数组最后一个元素的下一个数字，即nums.length或nums[nums.length - 1] + 1。代码如下：

var missingNumber = function(nums) {
    nums.sort((a,b)=>{return a - b;});
    for (let i = 0, len = nums.length; i < len; i++) {
        if (i != nums[i]) {
            return i;
        }
    }
    return nums[nums.length - 1] + 1;
};

其他实现：

var missingNumber = function(nums) {
    let missing = nums.length;
    for(let i = 0; i < nums.length; i++) {
        missing ^= i ^ nums[i]
    }
    return missing;
};

283. 移动零

• 给定一个数组nums，编写一个函数将所有0移动到数组的末尾，同时保持非零元素的相对顺序。
• 说明:
• 必须在原数组上操作，不能拷贝额外的数组。
• 尽量减少操作次数。

分析：将所有非零元素按照其顺序在原数组中从左依次排序，排完非零元素后  剩余数组长度的元素都置零。代码如下：

var moveZeroes = function(nums) {
    let count = 0;
    nums.forEach(function (val,index,arr) {
        if (val != 0) {
            arr[count] = val;
            count++;
        }
    });
    while (count < nums.length) {
        nums[count] = 0;
        count++;
    }
};

其他实现：

var moveZeroes = function(nums) {
    for(var i = nums.length - 1;i > -1;i--){
    	if(nums[i] == 0){
    		nums.splice(i,1)
    		nums.push(0)
    	}
    }
};

414. 第三大的数

• 给定一个非空数组，返回此数组中第三大的数。如果不存在，则返回数组中最大的数。要求算法时间复杂度必须是O(n)。

分析：将数组按降序排序去重后，判断数组长度如果小于三则返回数组的第一个元素即最大元素，若数组长度大于等于三，则返回数组的第三个元素，即为数组中第三大的数。代码如下：

var thirdMax = function(nums) {
    nums.sort(function (a,b) {
      return b - a;
    });
    nums = [...new Set(nums)]; // Set类型不能访问使用[]或.访问其中的某一元素 所以此时应该使用 拓展字符串将其转换回数组 相较更方便操作一些
    let len = nums.length;
    return len < 3 ? nums[0] : nums[2];
};

448. 找到所有数组中消失的数字

• 给定一个范围在  1 ≤ a[i] ≤ n ( n = 数组大小 ) 的整型数组，数组中的元素一些出现了两次，另一些只出现一次。
• 找到所有在 [1, n] 范围之间没有出现在数组中的数字。
• 您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。

代码如下：

var findDisappearedNumbers = function(nums) {
    let len = nums.length, disNums = [], count = 1, i = 0;
    nums = [...new Set(nums)]; // 数组去重
    nums.sort((a,b) => {return a - b;});  // 数组升序排序
    while (i < nums.length) {  // 当数组中的元素与count元素相等时才接着往下遍历数组，否则就将count存进返回的结果数组中
        if (nums[i] != count) {
            disNums.push(count);
        } else {
            i++;
        }
        count++;
    }
    while(disNums.length < len - nums.length) {  // 当缺失的是末尾的数字时，通过几个数组长度的比较，判断是否需往结果数组中添加元素
        disNums.push(count);
        count++;
    }
    return disNums;
};

其他实现：

var findDisappearedNumbers = function(nums) {
    var res = [],
    length = nums.length;
    
    for(var i = 0; i < length;i++){
        var m = Math.abs(nums[i]) - 1; //这里须取绝对值，因为在之前的操作中这里可能已经被置为负值，这里判断需要按照原值进行。
        nums[m] = nums[m] > 0 ? -nums[m] : nums[m];
    }
    for(var j = 0;j < length;j++){
        if(nums[j] >= 0) res.push(j + 1);
    }
    return res
};

485. 最大连续1的个数

• 给定一个二进制数组， 计算其中最大连续1的个数。
• 注意：
• 输入的数组只包含 0 和1。
• 输入数组的长度是正整数，且不超过 10,000。

分析：遍历数组，将数组中多段连续1的个数存放在一个数组中，最后数组中元素的最大值即为最大连续1的个数。daimaruxia

扫描二维码关注公众号，回复： 2625007 查看本文章

var findMaxConsecutiveOnes = function(nums) {
    let conArr = [], count = 0;
    nums.forEach((val,index,arr) => {
        if (val == 1) {
            count++;
        } else {
            conArr.push(count);
            count = 0;
        }
    });
    conArr.push(count);
    return Math.max(...conArr);
};

其他实现：

var findMaxConsecutiveOnes = function(nums) {
    let max = 0;
    let cur = 0;
    nums.map(function (num) {
        if(num == 1){
            cur++;
            max = cur > max ? cur : max;
        }
        else{
            cur = 0;
        }
    });
    return max;
};