这是悦乐书的第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+篇，公众号对话框回复【数据结构与算法】、【算法】、【数据结构】中的任一关键词，获取系列文章合集。

以上就是全部内容，如果大家有什么好的解法思路、建议或者其他问题，可以下方留言交流，点赞、留言、转发就是对我最大的回报和支持！