三、leetcode - 数组（JS）

217. 存在重复元素

输入: [1,2,3,1]
输出: true

/**
 * @param {number[]} nums
 * @return {boolean}
 */
var containsDuplicate = function(nums) {
    let map = {};
    for(let item of nums) {
        if(map[item]) {
            return true;
        }
        map[item] = true;
    }
    return false;
};

349. 两个数组的交集

输出结果中的每个元素一定是唯一的

map 双循环

输入： nums1 = [1,2,2,1], nums2 = [2,2]
输出： [2]

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersection = function(nums1, nums2) {
    let map = {};
    let res = [];
    for(let item of nums1) {
        map[item] = true;
    }
    for(let item of nums2) {
        if(map[item]) {
            res.push(item);
            map[item] = false;
        }
    }
    return res;
};

350. 两个数组的交集 II

输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致

双数组双指针

输入： nums1 = [1,2,2,1], nums2 = [2,2]
输出： [2,2]

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function(nums1, nums2) {
    let map = {};
    let res = [];
    for(let item of nums1) {
        map[item] = (map[item] || 0) + 1;
    }
    for(let item of nums2) {
        if(map[item]) {
            res.push(item);
            map[item]--;
        }
    }
    return res;
};

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function(nums1, nums2) {
    nums1.sort((a, b) => a - b);
    nums2.sort((a, b) => a - b);
    let res = [];
    let l1 = nums1.length - 1;
    let l2 = nums2.length - 1;
    while(l1 >= 0 && l2 >= 0) {
        if(nums1[l1] === nums2[l2]) {
            res.push(nums1[l1]);
            l1--;
            l2--;
        }
        if(nums1[l1] > nums2[l2]) l1--;
        if(nums1[l1] < nums2[l2]) l2--;
    }
    return res;
};

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
var intersect = function(nums1, nums2) {
    let res = [];
    let l1 = 0;
    let l2 = 0;
    nums1.sort((a, b) => a - b);
    nums2.sort((a, b) => a - b);
    while(l1 < nums1.length && l2 < nums2.length) {
        if(nums1[l1] === nums2[l2]) {
            res.push(nums1[l1]);
            l1++;
            l2++;
        }
        if(nums1[l1] > nums2[l2]) {
            l2++;
        }
        if(nums1[l1] < nums2[l2]) {
            l1++;
        }
    }
    return res;
};

1. 两数之和 输入无序数组

map

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

输入： nums = [3,2,4], target = 6
输出： [1,2]

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    let map = {};
    for(let i = 0; i < nums.length; i++) {
        if(map[nums[i]] !== undefined) {
            return [map[nums[i]], i];
        }
        map[target - nums[i]] = i;
    }
};

167. 两数之和 II 输入有序数组

单数组左右对撞指针

输入：numbers = [2,7,11,15], target = 9
输出：[1,2]
解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

/**
 * @param {number[]} numbers
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(numbers, target) {
    let l = 0;
    let r = numbers.length - 1;
    while(l <= r) {
        if(numbers[l] + numbers[r] === target) return [l+1, r+1];
        if(numbers[l] + numbers[r] > target) r--;
        if(numbers[l] + numbers[r] < target) l++;
    }
};

977. 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

单数组左右对撞指针

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var sortedSquares = function(nums) {
    let res = [];
    let l = 0;
    let r = nums.length -1;
    while(l <= r){
        let l_val = nums[l] * nums[l];
        let r_val = nums[r] * nums[r];
        if(l_val <= r_val) {
            res.unshift(r_val);
            r--;
        }else{
            res.unshift(l_val);
            l++;
        }
    }
    return res;
};

11. 盛最多水的容器

单数组左右对撞指针

给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明：你不能倾斜容器。

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

/**
 * @param {number[]} height
 * @return {number}
 */
var maxArea = function(height) {
    let l = 0;
    let r = height.length - 1;
    let res = 0;
    while(l < r) {
        if(height[l] <= height[r]) {
            res = Math.max(height[l] * (r - l), res);
            l++
        } else {
            res = Math.max(height[r] * (r - l), res);
            r--
        }
    }
    return res;
};

15. 三数之和

单数组左右对撞指针

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

输入： nums = [-1,0,1,2,-1,-4]
输出： [[-1,-1,2],[-1,0,1]]

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var threeSum = function(nums) {
    let res = [];
    nums.sort((a, b) => a - b);
    for(let i = 0; i < nums.length - 2; i++) {
        let cur = nums[i];
        if(i - 1 >= 0 && cur === nums[i - 1]) continue;
        let left = i + 1;
        let right = nums.length - 1;
        while(left < right) {
            let l = nums[left];
            let r = nums[right];
            if(l + r + cur === 0) {
                res.push([cur, l, r]);
                // 跳过左右两边相同的值
                while(left < right && nums[left] === l) left++;
                while(left < right && nums[right] === r) right--;

            }
            if(l + r + cur > 0) right--;
            if(l + r + cur < 0) left++;
        }
    }
    return res;
};

88. 合并两个有序数组

双数组双指针

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

/**
 * @param {number[]} nums1
 * @param {number} m
 * @param {number[]} nums2
 * @param {number} n
 * @return {void} Do not return anything, modify nums1 in-place instead.
 */
var merge = function(nums1, m, nums2, n) {
    let len = m + n - 1;
    let mLen = m - 1;
    let nLen = n - 1;
    while(mLen >= 0 && nLen >= 0) {
        if(nums1[mLen] > nums2[nLen]) {
            nums1[len] = nums1[mLen];
            mLen--;
        } else {
            nums1[len] = nums2[nLen];
            nLen--;
        }
        len--;
    }
    while(nLen >= 0) {
        nums1[len] = nums2[nLen];
        nLen--;
        len--
    }
};

14. 最长公共前缀

使用reduce两两比较。

输入： strs = ["flower","flow","flight"]
输出： "fl"

/**
 * @param {string[]} strs
 * @return {string}
 */
var longestCommonPrefix = function(strs) {
    let len = strs.length;
    if(len === 0) return '';
    if(len === 1) return strs[0];
    return strs.reduce(function(a, b) {
        let res = '';
        for(let i = 0; i < a.length; i++) {
            if(a[i] === b[i]) {
                res += a[i];
            } else {
                break;
            }
        }
        return res;
    });
};

169. 多数元素

map

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

输入： [3,2,3]
输出： 3

/**
 * @param {number[]} nums
 * @return {number}
 */
var majorityElement = function(nums) {
    let count = {};
    let mid = nums.length >> 1;
    for(let i = 0; i < nums.length; i++) {
        const element = nums[i];
        count[element] ? count[element]++ : count[element] = 1;
        if(count[element] > mid) {
            return element;
        }
    }
};

17. 电话号码的字母组合

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

输入： digits = "23"
输出： ["ad","ae","af","bd","be","bf","cd","ce","cf"]

/**
 * @param {string} digits
 * @return {string[]}
 */
var letterCombinations = function(digits) {
    if(digits.length === 0) return [];
    const res = [];
    const map = { '2': 'abc', '3': 'def', '4': 'ghi', '5': 'jkl', '6': 'mno', '7': 'pqrs', '8': 'tuv', '9': 'wxyz' };
    function dfs(str, deep) {
        console.info(str);
        if(str.length === digits.length){
            res.push(str);
            return;
        }
        let curStr = map[digits[deep]];
        for(let i = 0; i < curStr.length; i++) {
            dfs(str + curStr[i], deep + 1);
        }
    }
    dfs('', 0); 
    return res;
};