LeetCode算法题-Majority Element(Java实现)

这是悦乐书的第181次更新,第183篇原创

01 看题和准备

今天介绍的是LeetCode算法题中Easy级别的第40题(顺位题号是169)。给定大小为n的数组,找到数组中出现次数超过n/2的元素。假设该数组非空,并且该元素始终存在于数组中。例如:

输入:[3,2,3]
输出:3

输入:[2,2,1,1,1,2,2]
输出:2

本次解题使用的开发工具是eclipse,jdk使用的版本是1.8,环境是win7 64位系统,使用Java语言编写和测试。

02 第一种解法

我们可以先将数组排序,然后使用for循环遍历前n-1个元素,使用count计算元素出现的次数。

如果第i个元素与第i+1个元素相等,并且i等于数组长度减2,那么count要加两次,否则只用加1此,接着判断count是否大于n/2,如果大于则返回第i个元素。

如果第i个元素与第i+1个元素不相等,这时需要判断i是否大于0并且第i个元素与第i-1个元素是否相等,如果相等,count加1,接着判断count是否大于n/2,如果大于则返回第i个元素,如果不相等,count归为0,再重新开始循环。

因为题目已经表示数组不会为空,所以不需要考虑特殊情况,但是有一点就要考虑,那就是如果没有找到那个出现次数大于n/2的元素,需要返回数组最后一个元素。

public int majorityElement(int[] nums) {
    int size = nums.length / 2;
    int result = nums[nums.length - 1];
    Arrays.sort(nums);
    int count = 0;
    for (int i = 0; i < nums.length - 1; i++) {
        if (nums[i] == nums[i + 1]) {
            if (i == nums.length - 2) {
                count++;
            }
            count++;
            if (count > size) {
                return nums[i];
            }
        } else {
            if (i > 0 && nums[i] == nums[i - 1]) {
                count++;
                if (count > size) {
                    return nums[i];
                }
            } else {
                count = 0;
            }
        }
    }
    return result;
}

此解法的时间复杂度是O(n log(n))+O(n),空间复杂度是O(1)。

03 第二种解法

还是先利用Arrays的排序方法,将数组排序。题目要找的是出现次数大于n/2的元素,那么排过序后,假如存在该元素,那么数组的中间位元素,即nums[n/2]应该就是该元素。

但是,还需要一步判断,如果数组长度是偶数,比如是4,那么中间位元素是nums[2],即是数组第三位元素,这时就需要判断nums[1]和nums[0]是否相等了,如果相等那么返回nums[0]或者nums[n/2 – 1]都行。

public int majorityElement2(int[] nums) {
    int len = nums.length;
    if(len == 1) return nums[0];
    Arrays.sort(nums);
    if (len%2 == 0 && nums[0] == nums[len/2 - 1]) {
        return nums[0];
    }
    return nums[len/2];
}

此解法的时间复杂度是O(n log(n)),空间复杂度是O(1)。

04 第三种解法

取一临时变量candidate,存储出现次数大于n/2的元素。取一临时变量count,存储出现次数.

进入循环,判断count是否等于0,等于0,就将当前元素赋值给candidate。接着判断当前元素是否和candidate相等,相等的话count加1,否则减1,直到遍历完所有元素。

此解法,关键在于,碰到当前重复元素就加1,没碰到就减1,如果最后count不等于0,当前重复元素就是出现次数最多的元素,如果count变成0了,说明之前遇到的重复元素和不重复元素出现次数是相等的,相互抵消了,就需要重新去获取当前重复元素了。

public int majorityElement3(int[] nums) {
    int count = 0;
    int candidate = 0;
    for (int i = 0; i < nums.length; i++) {
        if (count == 0) {
            candidate = nums[i];
        }
        if (nums[i] == candidate) {
            count++;
        } else {
            count--;
        }
    }
    return candidate;
}

此解法的时间复杂度是O(n),空间复杂度是O(1)。

05 第四种解法

使用HashMap,key存储数组元素,value存储元素出现的次数,如果最后value值大于n/2,那么该key就是出现次数最多的元素。

public int majorityElement4(int[] nums) {
    Map<Integer, Integer> map = new HashMap<>();
    int freq = 0;
    for (int i = 0; i < nums.length; i++) {
        if (map.containsKey(nums[i])) {
            freq = map.get(nums[i]) + 1;
            map.put(nums[i], freq);
        } else {
            freq = 1;
            map.put(nums[i], 1);
        }
        if (freq > nums.length / 2)
            return nums[i];
    }
    return nums[nums.length-1];
}

此解法的时间复杂度是O(n),空间复杂度是O(n)。

06 测试与验证

针对以上四种解法,使用随机的数组和编写了简易的测试代码来测试这几种方法。如下:

public static void main(String[] args) {
    Easy_169_MajorityElement instance = new Easy_169_MajorityElement();
    int[] arg = { 3, 2, 3, 1, 2, 3, 2, 3};
    long start = System.nanoTime();
    int result = instance.majorityElement(arg);
    long end = System.nanoTime();
    System.out.println("majorityElement---输入:" + Arrays.toString(arg) + " , 输出:" + result + " , 用时:" + ((end - start) / 1000) + "微秒");
    int[] arg2 = { 3, 2, 3, 1, 2, 3, 2, 3};
    long start2 = System.nanoTime();
    int result2 = instance.majorityElement2(arg2);
    long end2 = System.nanoTime();
    System.out.println("majorityElement2---输入:" + Arrays.toString(arg2) + " , 输出:" + result2 + " , 用时:" + ((end2 - start2) / 1000) + "微秒");
    int[] arg3 = { 3, 2, 3, 1, 2, 3, 2, 3};
    long start3 = System.nanoTime();
    int result3 = instance.majorityElement3(arg3);
    long end3 = System.nanoTime();
    System.out.println("majorityElement3---输入:" + Arrays.toString(arg3) + " , 输出:" + result3 + " , 用时:" + ((end3 - start3) / 1000) + "微秒");
    int[] arg4 = { 3, 2, 3, 1, 2, 3, 2, 3};
    long start4 = System.nanoTime();
    int result4 = instance.majorityElement4(arg4);
    long end4 = System.nanoTime();
    System.out.println("majorityElement4---输入:" + Arrays.toString(arg4) + " , 输出:" + result4 + " , 用时:" + ((end4 - start4) / 1000) + "微秒");
}

测试结果如下:

majorityElement---输入:[1, 2, 2, 2, 3, 3, 3, 3] , 输出:3 , 用时:211微秒
majorityElement2---输入:[1, 2, 2, 2, 3, 3, 3, 3] , 输出:3 , 用时:5微秒
majorityElement3---输入:[3, 2, 3, 1, 2, 3, 2, 3] , 输出:2 , 用时:4微秒
majorityElement4---输入:[3, 2, 3, 1, 2, 3, 2, 3] , 输出:3 , 用时:62微秒

07 小结

算法专题目前已连续日更超过一个月,算法题文章40+篇,公众号对话框回复【数据结构与算法】、【算法】、【数据结构】中的任一关键词,获取系列文章合集。

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

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