数组算法题解记录1

1、 26. 删除有序数组中的重复项

1.双指针（初版）
首先注意数组是有序的，那么重复的元素一定会相邻。要求删除重复元素，实际上就是将不重复的元素移到数组的左侧。

考虑用 2 个指针，一个在前记作 p，一个在后记作 q，算法流程如下：
比较 p 和 q 位置的元素是否相等，如果相等，q 后移 1 位；
如果不相等，将 q 位置的元素复制到 p+1 位置上，p 后移一位，q 后移 1 位；

重复上述过程，直到 q 等于数组长度。返回 p + 1，即为新数组长度。

/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function(nums) {
    let p = 0;
    let q = 1;
    let len = nums.length;

    while(q

2.双指针（优化版）
判断条件合并
如果数组中没有重复元素，按照上面的方法，每次比较时 nums[p] 都不等于 nums[q]，因此就会将 q 指向的元素原地复制一遍，这个操作其实是不必要的。
因此我们可以添加一个小判断，当 q - p > 1 时，才进行复制。

/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function(nums) {
    let p = 0;
    let q = 1;
    let len = nums.length;

    while(q1){
                nums[p+1] = nums[q];
            }
            p++;
        }
        q++;
    }
    return p+1;
};

2、寻找数组的中心下标leetcode 724

方法一：前缀和
左侧求和值*2+中心索引处的值=总和
当中心索引左侧或右侧没有元素时，即为零个项相加，这在数学上称作「空和」。在程序设计中我们约定「空和是零」。

/**
 * @param {number[]} nums
 * @return {number}
 */
var pivotIndex = function(nums) {
    let len = nums.length;
    let total = 0;
    let left = 0;

    for(let i = 0; i

3、搜索插入位置 leetcode35

1.单纯遍历求解
考虑到要返回插入的位置 pos，它成立的条件为：nums[pos−1]< target ≤ nums[pos]
其中 nums 代表排序数组。由于如果存在这个目标值，我们返回的索引也是 pos，因此我们可以将两个条件合并得出最后的目标：在一个有序数组中找第一个大于等于 target 的下标。

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var searchInsert = function(nums, target) {
    let len = nums.length;

    if(nums[len-1] =target) {
            return i;
        }
    }
    return -1;
};

2.二分查找

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number}
 */
var searchInsert = function(nums, target) {
    const len = nums.length;
    let left = 0;
    let right = len-1;
    let pos = len;

    while(left <= right){
        let mid = Math.floor((left+right)/2);
        if(target <= nums[mid]){
            pos = mid;
            right = mid-1;
        } else {
            left = mid+1;
        }
    }
    return pos;
};

4、合并区间 leetcode56

思路

prev 初始为第一个区间，cur 表示当前的区间，res 表示结果数组

开启遍历，尝试合并 prev 和 cur，合并后更新到 prev。合并后的新区间还可能和后面的区间重合，继续尝试合并新的 cur，更新给 prev。直到不能合并（prev[1] < cur[0]），此时将 prev 区间推入 res 数组。

合并的策略

原则上要更新prev[0]和prev[1]，即左右端:
prev[0] = min(prev[0], cur[0])
prev[1] = max(prev[1], cur[1])
但如果先按区间的左端排升序，就能保证 prev[0] < cur[0]
所以合并只需这条： prev[1] = max(prev[1], cur[1])

易错点

我们是先合并，遇到不重合再推入 prev。当考察完最后一个区间，后面没区间了，遇不到不重合的区间，最后的 prev 没推入 res,要单独补上。

/**
 * @param {number[][]} intervals
 * @return {number[][]}
 */
var merge = function(intervals) {
    intervals.sort((a,b) => a[0] - b[0]); // 以“区间开始”升序排序
    let prev = intervals[0];
    let res = [];

    for(let i=0; i= cur[0]) {  // 有重合
            prev[1] = Math.max(prev[1], cur[1]);
        } else {
            res.push(prev);
            prev = cur;
        }
    }

    res.push(prev); // 补上最后一个prev
    return res;
};

5、 217. 存在重复元素

给你一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {
    let s = new Set();

    for(let i=0; i

6、136. 只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

/**
* @param {number[]} nums
* @return {number}
*/
var singleNumber = function(nums) {
   let res = 0;
   for(let i=0; i

7、 350. 两个数组的交集 II

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
function getMap(arr){
    let map = new Map();
    for(let i = 0; i 0) {
            res.push(cur);
            m1.set(cur, count-1);
        }
    }
    return res;
};

8、 122. 买卖股票的最佳时机 II

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    let profit = 0
    let len = prices.length;
    for(let i = 1; i < len; i++) {
        let temp = prices[i] - prices[i-1];
        if(temp > 0) {
            profit = profit +  temp;
        }
    }
    return profit;
};

9、 66. 加一

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

/**
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function(digits) {
    let len = digits.length;
     
    for(let i = len-1;i>=0;i--){
        let cur = digits[i];
        if(cur < 9){
            digits[i]++;
            return digits;
        }
        digits[i] = 0;
    }

    let arr = [];
    arr.push(1);
    for(let i= 0; i