这是悦乐书的第254次更新，第267篇原创
01 看题和准备
今天介绍的是LeetCode算法题中Easy级别的第121题（顺位题号是532）。给定一个整数数组和一个整数k，您需要找到数组中唯一的k-diff对的数量。 这里k-diff对被定义为整数对（i，j），其中i和j都是数组中的数字，它们的绝对差是k。例如：
输入：[3,1,4,1,5]，k = 2
输出：2
说明：数组中有两个2-diff对，（1,3）和（3,5）。虽然我们在输入中有两个1，但我们应该只返回唯一对的数量。
输入：[1,2,3,4,5]，k = 1
输出：4
说明：数组中有四个1-diff对，（1,2），（2,3），（3,4）和（4,5）。
输入：[1,3,1,5,4]，k = 0
输出：1
说明：数组中有一个0-diff对，（1,1）。
注意：
-
对（i，j）和（j，i）计为同一对。
-
数组的长度不会超过10,000。
-
给定输入中的所有整数都属于以下范围：[-1e7, 1e7]。
本次解题使用的开发工具是eclipse，jdk使用的版本是1.8，环境是win7 64位系统，使用Java语言编写和测试。
02 第一种解法
暴力解法。先排序，然后使用两层循环，计算不同元素的绝对值，如果等于k，次数就加1。在外面第一层循环那里，如果前后元素相同，就跳过当前循环，进行下一次循环。在内层循环那里同样做了类似的判断，排除重复计算。
此解法的时间复杂度是O(n^2)，空间复杂度是O(1)。
public int findPairs(int[] nums, int k) {
if (nums == null || nums.length == 0 || k < 0) {
return 0;
}
Arrays.sort(nums);
int count = 0;
for (int i=0; i<nums.length; i++) {
int n = nums[i];
if (i >= 1 && nums[i-1] == nums[i]) {
continue;
}
for (int j=i+1; j<nums.length; j++) {
if (j >= i+2 && nums[j-1] == nums[j]) {
continue;
}
if (Math.abs(n - nums[j]) == k) {
count++;
}
}
}
return count;
}
03 第二种解法
第一种解法时间复杂度太高了，得降低点。第一种解法，我们是做减法，求绝对值，来判断是否等于k，我们也可以做加法，拿当前元素加上k，然后看新元素是否存在于数组中。同时还要考虑重复的计算数据，因此参与计算的元素是唯一的，对此我们可以使用HashMap，已元素值作为key，该元素值出现次数为value。遍历key，如果key加上k后的值存在于map中，次数加1，另外如果k为0的时候，只需要判断每个key所对应的value是否大于等于2即可。
此解法的时间复杂度是O(n)，最坏情况也可能是O(n^2)，空间复杂度是O(n)。
public int findPairs2(int[] nums, int k) {
if (nums == null || nums.length == 0 || k < 0) {
return 0;
}
Map<Integer,Integer> map = new HashMap<Integer,Integer>();
for (int n : nums) {
map.put(n, map.getOrDefault(n, 0)+1);
}
int count = 0;
if (k == 0) {
for (Integer key: map.keySet()) {
if (map.get(key) >= 2) {
count++;
}
}
} else {
for (Integer key: map.keySet()) {
if (map.containsKey(key+k)) {
count++;
}
}
}
return count;
}
04 第三种解法
对于第二种解法，还可以将判断放在循环体里面。
public int findPairs3(int[] nums, int k) {
if (nums == null || nums.length == 0 || k < 0) {
return 0;
}
Map<Integer,Integer> map = new HashMap<Integer,Integer>();
for (int n : nums) {
map.put(n, map.getOrDefault(n, 0)+1);
}
int count = 0;
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
if (k == 0) {
if (entry.getValue() >= 2) {
count++;
}
} else {
if (map.containsKey(entry.getKey()+k)) {
count++;
}
}
}
return count;
}
05 第四种解法
使用HashSet。使用两个HashSet，同样分为两种情况：k等于0和K不等于0。
如果k等于0时，对数组进行遍历，如果当前元素不存在于set1中，就添加进set1，如果存在set1中，就去判断是否存在于set2中，如果不存在，次数就加1，并将元素添加进set2中。
如果k不等于0，遍历数组，将当前元素添加进set1，将当前元素加上k后再添加进set2，然后使用retainAll方法，将set1中不包含set2元素的元素剔除掉（也就是两set的交集），最后count等于set1中元素的个数。
public int findPairs4(int[] nums, int k) {
if (nums == null || nums.length == 0 || k < 0) {
return 0;
}
Set<Integer> set1 = new HashSet<Integer>();
Set<Integer> set2 = new HashSet<Integer>();
int count = 0;
if (k == 0) {
for (int n : nums) {
if (!set1.contains(n)) {
set1.add(n);
} else {
if (!set2.contains(n)){
count++;
}
set2.add(n);
}
}
} else {
for (int n : nums) {
set1.add(n);
set2.add(n + k);
}
set1.retainAll(set2);
count = set1.size();
}
return count;
}
06 第五种解法
使用双指针。还是先将数据排序，定义左右两个指针，分别从0开始，如果左右指针相等，说明是循环的第一次或者重复了，就需要将右指针往后移动一位。如果左指针所指向元素加上k后等于右指针的元素，那么次数加1，接着要判断，如果右指针所指向位置后面的元素和当前元素相等，那么右指针继续往后移动。如果左指针所指向元素加上k后小于右指针的元素，说明左边的元素小了，左指针向前移动。如果左指针所指向元素加上k后大于右指针的元素，说明右边的元素小了，右指针向前移动。
此解法的时间复杂度是O(n log(n))，空间复杂度是O(1)。
public int findPairs5(int[] nums, int k) {
if (nums == null || nums.length == 0 || k < 0) {
return 0;
}
Arrays.sort(nums);
int count = 0;
int start = 0, end = 0;
while (end < nums.length) {
if (start == end) {
end++;
} else if (nums[start] + k == nums[end]) {
count++;
while (end + 1 < nums.length && nums[end] == nums[end + 1]) {
end++;
}
end++;
} else if (nums[start] + k < nums[end]) {
start++;
} else if (nums[start] + k > nums[end]) {
end++;
}
}
return count;
}
07 小结
此题的测试用例中，k出现了负值，所以在特殊情况判断中，还需要判断k小于0，这也是本题不严谨的一个地方。
算法专题目前已日更超过三个月，算法题文章121+篇，公众号对话框回复【数据结构与算法】、【算法】、【数据结构】中的任一关键词，获取系列文章合集。
以上就是全部内容，如果大家有什么好的解法思路、建议或者其他问题，可以下方留言交流，点赞、留言、转发就是对我最大的回报和支持！