Majority Element II 解答

Question

Given an integer array of size n, find all elements that appear more than ⌊ n/3 ⌋ times. The algorithm should run in linear time and in O(1) space.

Majority Element I

A Linear Time Voting Algorithm

Solution 1 -- Binary Search

我们发现一个规律。如果是大于 1/k 的majority，排好序的数组中，它们可能出现的位置是

len / k, len  * 2/ k, len * 3 / k, ...

所以我们可以依次用二分查找法查找在 len * i / k 的各个点的start和end position，然后算长度，判断是否满足条件。

动态一些的方法是下一个待判断点的坐标为 prevEnd + len / k + 1

如图，绿线为start point 红线为end point

Time complexity O(n log n), space O(1)

public class Solution {
    public List<Integer> majorityElement(int[] nums) {
        Arrays.sort(nums);
        List<Integer> result = new ArrayList<Integer>();
        int len = nums.length;
        if (len < 1)
            return result;
        int candidate1 = nums[len / 3];
        // Find start and end of candidate1
        int[] range1 = searchRange(nums, candidate1);
        int num1 = range1[1] - range1[0] + 1;
        if (num1 > len / 3)
            result.add(candidate1);
        // Find start and end of candidate2
        int index = len / 3 + range1[1] + 1;
        if (index >= len)
            return result;
        int candidate2 = nums[index];
        int[] range2 = searchRange(nums, candidate2);
        int num2 = range2[1] - range2[0] + 1;
        if (num2 > len / 3 && candidate2 != candidate1)
            result.add(candidate2);
        return result;
    }
    
    private int[] searchRange(int[] nums, int target) {
        int start = 0, end = nums.length - 1, mid;
        int[] result = new int[2];
        result[0] = -1;
        result[1] = -1;
        while (start + 1 < end) {
            mid = (end - start) / 2 + start;
            if (nums[mid] >= target)
                end = mid;
            else
                start = mid;
        }
        if (nums[start] == target)
            result[0] = start;
        else if (nums[end] == target)
            result[0] = end;
        
        start = 0;
        end = nums.length - 1;
        
        while (start + 1 < end) {
            mid = (end - start) / 2 + start;
            if (nums[mid] > target)
                end = mid;
            else
                start = mid;
        }
        if (nums[end] == target)
            result[1] = end;
        else if (nums[start] == target)
            result[1] = start;
        return result;
    }
}

Solution 2 -- Moore Voting Algorithm

Time complexity O(n), space cost O(1)

public class Solution {
    public List<Integer> majorityElement(int[] nums) {
        int count1 = 0, count2 = 0;
        Integer num1 = null, num2 = null;
        int len = nums.length;
        for (int current : nums) {
            if (num1 != null && current == num1.intValue()) {
                count1++;
            } else if (num2 != null && current == num2.intValue()) {
                count2++;
            } else if (num1 == null || count1 == 0) {
                num1 = current;
                count1 = 1;
            } else if (num2 == null || count2 == 0) {
                num2 = current;
                count2 = 1;
            } else {
                count1--;
                count2--;
            }
        }
        // Check whether num1, num2, num3 are valid
        count1 = 0;
        count2 = 0;
        for (int current : nums) {
            if (current == num1.intValue()) {
                count1++;
            } else if (current == num2.intValue()) {
                count2++;
            }
        }
        List<Integer> result = new ArrayList<Integer>();
        if (count1 > len / 3) {
            result.add(num1);
        }
        if (count2 > len / 3) {
            result.add(num2);
        }
        return result;
    }
}