LeetCode算法题-K-diff Pairs in an Array(Java实现)

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

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

    原文作者:悦乐书
    原文地址: https://www.jianshu.com/p/eef7d7d4cdff
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞