LeetCode_16：Contains Duplicate II

1、总结

• （a）在实际应用中，面对多种解法的时候，时间复杂度和空间复杂度依照什么标准去取舍？

2、题目

Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k.

Example 1:

	Input: nums = [1,2,3,1], k = 3
	Output: true

Example 2:

	Input: nums = [1,0,1,1], k = 1
	Output: true

Example 3:

	Input: nums = [1,2,3,1,2,3], k = 2
	Output: false

3、我的解法

方法一：暴力破解，循环遍历每个元素nums[i]之后的k个元素，如有重复则返回true

	/**
	 * @param {number[]} nums
	 * @param {number} k
	 * @return {boolean}
	 */
	var containsNearbyDuplicate = function(nums, k) {
	    for(let i = 0; i < nums.length; i++) {
	        for (let j = i+1; (j <= (i+k) && j < nums.length); j++) {
	            if(nums[i] == nums[j]) {
	                return true;
	            }
	        }
	    }
	    return false;
	};

看这时间复杂度，第一次提交代码时有console，直接报超时，第二次才通过：

因为有规定重复元素的相差距离不超过K，因此排序方法应该是不能用了。

如果使用map呢？加一个判断条件试试：
方法二：用map存储单个元素出现的位置index

	/**
	 * @param {number[]} nums
	 * @param {number} k
	 * @return {boolean}
	 */
	var containsNearbyDuplicate = function(nums, k) {
	    let temp = {};
	    for(let i = 0; i < nums.length; i++) {
	        if(nums[i] in temp) {
	            if( (i - temp[nums[i]]) <= k) {
	                return true;
	            } else {
	                temp[nums[i]] = i;
	            }
	        } else {
	            temp[nums[i]] = i;
	        }
	    }
	    return false;
	};

之前都是用map存储元素出现的次数，这里变成了出现的位置，用于判断位置相差是否超过K。
注意：当出现重复元素且位置超过K不符合规定时，需要更新map中元素的最新位置。
对方法二代码做一个简单优化：

	/**
	 * @param {number[]} nums
	 * @param {number} k
	 * @return {boolean}
	 */
	var containsNearbyDuplicate = function(nums, k) {
	    let temp = {};
	    for(let i = 0; i < nums.length; i++) {
	        if(nums[i] in temp && (i - temp[nums[i]]) <= k) {
	            return true;
	        } else {         
	            temp[nums[i]] = i;   
	        }
	    }
	    return false;
	};

时间复杂度还好，但是空间复杂度高，可以了解一下二者的均衡以及在实际开发中的取舍标准；

4、其他解法

由于这道题看不到solution，所以只有上网查了一下其他解法。
看到有一个滑动窗口解法： 先动手实现一下吧

	/**
	 * @param {number[]} nums
	 * @param {number} k
	 * @return {boolean}
	 */
	var containsNearbyDuplicate = function(nums, k) {
	
	    if(nums.length <= 1 || k <= 0) return false;    
	    
	    let temp = [];
	    for(let i = 0; i < nums.length; i++) {
	        if(temp.indexOf(nums[i]) > -1) {
	            return true;
	        } else {
	            temp.push(nums[i]);
	        }
	        if(temp.length >= k+1) {
	           temp.shift();
	        }
	    }
	    return false;
	};

调试的时候感觉还挺快的，没想到提交的时间复杂度竟然比暴力破解还要耗性能。