Leetcode的一些数组

Leetcode-27-移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

分析：这道题和昨天删除重复元素差不多又有些区别，区别在于昨天是把重复的给删了，今天只是删某一个元素

// 解法1，官方双指针 这道题的目标在于对原数组的直接修改
var removeElement = function(nums, val) {
    let flag = 0;
for(let item in nums){
if (nums[item] !== val){
nums[flag] = nums[item];
flag ++ 
}
}
return flag
};
// 解法2:利用while
var removeElement = function(nums, val){
  while (nums.indexOf(val) !== -1) {
    nums.splice(nums.indexOf(val),1)
  }
  return nums.length
}

在不修改原数组的前提下，我们还可以这么干

// 最简单的就是官方filter
var removeElement = function(nums, val) {
  let a = nums.filter((item)=>item !== val);
  console.log(a)
  return a
};
 // 再给出一个reduce版本
var removeElement = function(nums, val) {
  let a = nums.reduce((pre,curr)=>{
      curr !== val && pre.push(curr)
			return pre
  },[]);
  return a
};

Leetcode-35-搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

说明：这道题思路还是比较简单的，首先先看数组里面有没有，有就直接输出，没有的话遍历，找到第一个比他大的元素，插到该元素之前。

// 解法1
var searchInsert = function(nums, target) {
    let index =nums.indexOf(target);
if(index> -1){
    return index
} else {
    for(let i =0; i < nums.length;i++){
        if(nums[i]> target){
            return i
        }
    }
    return nums.length
}
};

//解法2 在for里加判断的话肯定能用while
var searchInsert = function(nums, target) {
    let index =nums.indexOf(target);
if(index> -1){
    return index
} else {
    let i = 0;
    while(nums[i]< target){
        i++
    }
    return i
}
};

// 解法3 二分查找
var searchInsert = function(nums, target) {
const n = nums.length;
    let left = 0, right = n - 1, ans = n;
    while (left <= right) {
        let mid = ((right - left) >> 1) + left;
        if (target <= nums[mid]) {
            ans = mid;
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return ans;
}

Leetcode-53-最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

说明：这道题是比较典型的动态规划问题，因为是连续子数组，所以一直累加，看当前累加值和目前的待选值的大小，如果待选值比之前累加值都大，就可以新起一个累加值的开头，否则就添加到累加值中

var maxSubArray = function(nums) {
    // Math.max(sum[i]+s[i],s[i])
    let sum = 0;
    let max = nums[0];
    for(let i =0; i < nums.length; i++ ){
        sum = Math.max(sum+nums[i],nums[i]);
        max = Math.max(max, sum)
    }
    return max
};

Leetcode-66-加一

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。你可以假设除了整数 0 之外，这个整数不会以零开头。

说明：有两种情况，如果最后一位不是9，那就直接最后一位加1，如果最后一位是9，那就前进一位，如果进一位之后之前那位还是9，也就是说还得接着进一位，直到不是9的为止

var plusOne = function(digits) {
const len = digits.length;
    for(let i = len - 1; i >= 0; i--) {
        digits[i]++;
        digits[i] %= 10;
        if(digits[i]!=0)
            return digits;
    }
    digits = [...Array(len + 1)].map(_=>0);;
    digits[0] = 1;
    return digits;
};

Leetcode-88-合并两个有序数组

将两个有序数组合并成一个有序数组

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中*，*使 nums1 成为一个有序数组

说明：如果没要求的话用一个新数组进行存储是很快的

var merge = function(nums1, m, nums2, n) {
    let num = nums1.concat(nums2)
    num.sort() // 直接用sort方法
    return num
};

// 最简单的方式
var merge = function(nums1, m, nums2, n) {
    nums1.splice(m,m+n,...nums2);
    console.log(nums1)
    return nums1.sort((a,b)=>a-b)
};

Leetcode-118-杨辉三角

给定一个非负整数 *numRows，*生成杨辉三角的前 numRows 行，在杨辉三角中，每个数是它左上方和右上方的数的和。

var generate = function(numRows) {
    let tri = [];
for(let i = 0; i < numRows; i++){
    const row = new Array(i+1).fill(1);
    for (let j = 1; j < row.length - 1; j++) {
            row[j] = tri[i - 1][j - 1] + tri[i - 1][j];
        }
        tri.push(row)
}
return tri
};

Leetcode-119-杨辉三角2

返回杨辉三角的第k行

说明：就是将杨辉三角计算出来输出第k行

var getRow = function(rowIndex) {
let tri = [];
for(let i = 0; i < rowIndex+1; i++){
    const row = new Array(i+1).fill(1);
    for (let j = 1; j < row.length - 1; j++) {
            row[j] = tri[i - 1][j - 1] + tri[i - 1][j];
        }
        tri.push(row)
}
return tri[rowIndex]
};

// 只保留最后一行
var getRow = function(rowIndex) {
let tri = [];
for(let i = 0; i < rowIndex+1; i++){
    const row = new Array(i+1).fill(1);
    for (let j = 1; j < row.length - 1; j++) {
            row[j] = tri[j - 1] + tri[j];
        }
        tri = row;
}
return tri
};

Leetcode-167-两数之和-输入有序数组

给定一个已按照 升序排列 的整数数组 numbers ，请你从数组中找出两个数满足相加之和等于目标数 target

// 解法1 暴力解题，但是在数据量大的时候会超时
var twoSum = function(numbers, target) {
for(let i =0; i < numbers.length; i++){
    let index = numbers.lastIndexOf(target- numbers[i])
    if( index> -1 && index !== i){
        return [i+1,index+1]
    }
}
};

// 解法2 用双指针的方式，相当于减少了一次循环
var twoSum = function(numbers, target) {
    let left = 0;
    let right = numbers.length -1;
    while(left < right){
        let sum = numbers[left]+ numbers[right];
        if(sum === target){
            return [left+1,right+1]
        }
        sum > target ? right-- :left++
    }
};

Leetcode-217-存在重复元素

定一个整数数组，判断是否存在重复元素。如果存在一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

// 暴力解法
var containsDuplicate = function(nums) {
    let arr = [];
    for(let i  of nums){
      if(arr.includes(i)){
          return true
      } else {
          arr.push(i)
      }
    }
    return false
};
// 利用set，相当于少了includes的循环，所以时间复杂度会降低很多
var containsDuplicate = function(nums) {
    let set = new Set();
    for(let i of nums){
        if(set.has(i)){
            return true
        }
        set.add(i)
    }
    return false
};

Leetcode-219-存在重复元素2

给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引 i 和 j，使得 nums [i] = nums [j]，并且 i 和 j 的差的 绝对值 至多为 k。

var containsNearbyDuplicate = function(nums, k) {
    const set = new Set();
    for(let i = 0; i < nums.length; i++) {
        if(set.has(nums[i])) {
            return true;
        }
        set.add(nums[i]);
        if(set.size > k) {
            console.log(nums[i-k],set)
            set.delete(nums[i-k]);
        }
    }
    return false;
};