leetcode解题总结（javascript）

一、输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

示例：

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

输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。

链接：https://leetcode-cn.com/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof

①push（）和 unshift（）

push（） 方法可以在数组的末属添加一个或多个元素
shift（） 方法把数组中的第一个元素删除
unshift（） 方法可以在数组的前端添加一个或多个元素
pop（） 方法把数组中的最后一个元素删除

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var exchange = function(nums) {
    let a = [];
    for( let i = 0; i < nums.length; i++){        
        if(nums[i] % 2 == 0){
            a.push(nums[i]);
        }else{
            a.unshift(nums[i]);
        }
    }
    return a;
};

②forEach+条件运算

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var exchange = function(nums) {
    const arr = []; // 奇数数组
    const brr = []; // 偶数数组
    nums.forEach(item => {
        item % 2 ? arr.push(item) : brr.push(item);
    });
    return arr.concat(brr);
};

这种方法比①执行更迅速

③双指针交换

可以利用“双指针”，分别是指向数组头部的指针 i，与指向数组尾部的指针 j。过程如下：

• i 向右移动，直到遇到偶数；j 向左移动，直到遇到奇数
• 检查 i 是否小于 j，若小于，交换 i 和 j 的元素，回到上一步骤继续移动；否则结束循环

时间复杂度是 O(N),空间复杂度是 O(1)。代码如下：

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var exchange = function(nums) {
    const length = nums.length;
    if (!length) {
        return [];
    }

    let i = 0,
        j = length - 1;
    while (i < j) {
        while (i < length && nums[i] % 2) i++;
        while (j >= 0 && nums[j] % 2 === 0) j--;

        if (i < j) {
            [nums[i], nums[j]] = [nums[j], nums[i]];
            i++;
            j--;
        }
    }

    return nums;
};

更佳

二、给定一个整数数组，判断是否存在重复元素。

如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

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

示例 2:
输入: [1,2,3,4]
输出: false

链接：https://leetcode-cn.com/problems/contains-duplicate

①set排重数组对比

var containsDuplicate = function(nums) {
    return Array.from(new Set(nums)).length != nums.length;
    //new Set(nums)  将重复的值去掉
    //Array.from(new Set(nums)).length  重新生成数组
    //与原数组的length进行对比
};

知识点

• ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。
  Set 本身是一个构造函数，用来生成 Set 数据结构。
  Set 结构不会添加重复的值

详细介绍：https://es6.ruanyifeng.com/#docs/set-map

• Array.from（） 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。
  从 Set 生成数组

const set = new Set(['foo', 'bar', 'baz', 'foo']);
Array.from(set);
// [ "foo", "bar", "baz" ]

②Set的size属性

var containsDuplicate = function(nums) {
    return new Set(nums).size != nums.length;
    //Set.prototype.size：返回Set实例的成员总数。
};

三、打家劫舍 动态规划

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。

示例 2：
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。

链接：https://leetcode-cn.com/problems/house-robber

/**
 * @param {number[]} nums
 * @return {number}
 */
var rob = function(nums) {
     const len = nums.length;
    if(len == 0)
        return 0;
    const dp = new Array(len + 1);
    dp[0] = 0;
    dp[1] = nums[0];
    for(let i = 2; i <= len; i++) {
        dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i-1]);
    }
    return dp[len];
};

详细解法见：https://leetcode-cn.com/problems/house-robber/solution/hua-jie-suan-fa-198-da-jia-jie-she-by-guanpengchn/