LeetCode_24：K-diff Pairs in an Array

这两天看redux，脑子有点绕，于是回来接着刷算法换换脑子…

1、总结

• 1、这道题需要考虑的情况有点多，数据重复和数据差值为0的情况一定要注意；
• 2、sort排序的时候遇到负数还以为需要特殊处理，结果发现没有return，基础语法错误（箭头函数的简写）
• 3、发现一个问题：我总是习惯一股脑地解决问题，以至于一段代码需要判断各种条件下的处理逻辑，显得代码结构混乱（例如方法二的操作）。其实不妨分步实现（例如解法三），结构分明，效率也不慢。
• 4、我偶然会先排序再处理问题，但是经过几次可以发现这样效率不高（排序消耗性能）。
• 5、待寻求时间复杂度最优解

2、题目

Given an array of integers and an integer k, you need to find the number of unique k-diff pairs in the array. Here a k-diff pair is defined as an integer pair (i, j), where i and j are both numbers in the array and their absolute difference is k.

Example 1:

	Input: [3, 1, 4, 1, 5], k = 2
	Output: 2
	Explanation: There are two 2-diff pairs in the array, (1, 3) and (3, 5).
	Although we have two 1s in the input, we should only return the number of unique pairs.

Example 2:

	Input:[1, 2, 3, 4, 5], k = 1
	Output: 4
	Explanation: There are four 1-diff pairs in the array, (1, 2), (2, 3), (3, 4) and (4, 5).

Example 3:

	Input: [1, 3, 1, 5, 4], k = 0
	Output: 1
	Explanation: There is one 0-diff pair in the array, (1, 1).

Note:

	1、The pairs (i, j) and (j, i) count as the same pair.
	2、The length of the array won't exceed 10,000.
	3、All the integers in the given input belong to the range: [-1e7, 1e7].

3、我的方法

方法一：暴力破解 运行超时

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {number}
 */
// 方法一：
var findPairs = function(nums, k) {
    let diffPairs = 0;    
    for(let i = 0; i < nums.length; i++) {        
        for(let j = 0; j < nums.length; i++) {            
            if(Math.abs(nums[i] - nums[j]) === Math.abs(k)) {
                diffPairs++;
            }            
        }
    }
    return diffPairs;
};

方法二：先排序，再遍历比对元素差值，统计符合条件的个数

	/**
	 * @param {number[]} nums
	 * @param {number} k
	 * @return {number}
	 */
	// 方法二：
	var findPairs = function(nums, k) {
	    let diffPairs = 0;
	    let tempMap = {};
	    
	    let sortedNums = nums.sort((a,b)=>{
	       return a-b;
	    });
	    
	    // console.log(sortedNums);
	    
	    for(let i = 0; i < sortedNums.length; i++) {       
	                
	        if((sortedNums[i] - k) in tempMap && tempMap[sortedNums[i] - k] === undefined) {
	            tempMap[sortedNums[i] - k] = sortedNums[i];
	            diffPairs++;
	        }
	        if(!(sortedNums[i] in tempMap)) {         
	            tempMap[sortedNums[i]] = undefined;    
	        }
	    }
	    return diffPairs;
	};

4、其他方法

方法三：搜到一个很棒的方法 利用Map统计num个数，再进行进一步计算

	/**
	 * @param {number[]} nums
	 * @param {number} k
	 * @return {number}
	 */
	// 方法三：
	var findPairs = function(nums, k) {
	    if(k < 0) {
	        return 0;
	    }
	    
	    const tempMap = new Map();
	    for(let num of nums) {
	        if(tempMap.has(num)) {
	            tempMap.set(num, tempMap.get(num)+1);
	        } else {
	            tempMap.set(num, 1);
	        }
	    }
	    
	    // console.log(tempMap);
	    
	    let pairsCount = 0;
	    for(let [num, count] of tempMap.entries()) {
	        if(k===0) {
	            if(tempMap.get(num) >= 2) {
	                pairsCount++;
	            }            
	        } else if(tempMap.has(num + k)) {
	            pairsCount++;
	        }
	    }
	    return pairsCount;
	};

出乎我的意料，效率竟然没有快很多：


方法四：其实这个方法有点像方法二，只是没有排序，而是直接检索±k的元素，但是效率提升很多

	/**
	 * @param {number[]} nums
	 * @param {number} k
	 * @return {number}
	 */
	// 方法四：
	var findPairs = function(nums, k) {
	    if (k < 0) return 0
	    
	    let m = new Map()
	    let op = 0
	    const n = nums.length
	
	    for (let i = 0; i < n; i++) {
	        if (m.has(nums[i])) {
	            if (k == 0 && m.get(nums[i]) == 1)
	                op++
	            m.set(nums[i], m.get(nums[i]) + 1)
	        } else {
	            if (m.has(nums[i] - k)) op++
	            if (m.has(nums[i] + k)) op++
	            m.set(nums[i], 1)
	        }
	    }		
	    return op
	};