Majority Element II

Majority Element II - Problem

Given an integer array nums of size n, find all elements that appear more than ⌊ n/3 ⌋ times.

The algorithm should run in linear time and use only constant extra space.

Note: There can be at most two elements that appear more than ⌊ n/3 ⌋ times in any array.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,2,3]

› Output: [3]

💡 Note: Element 3 appears 2 times out of 3 total. Since 2 > ⌊3/3⌋ = 1, element 3 is a majority element.

Example 2 — No Majority

$ Input: nums = [1]

› Output: [1]

💡 Note: Element 1 appears 1 time out of 1 total. Since 1 > ⌊1/3⌋ = 0, element 1 is a majority element.

Example 3 — Two Majority Elements

$ Input: nums = [1,2]

› Output: [1,2]

💡 Note: Both elements appear 1 time out of 2 total. Since 1 > ⌊2/3⌋ = 0, both are majority elements.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 M Microsoft 28

The key insight is that at most 2 elements can appear more than n/3 times in any array. The optimal approach uses the Boyer-Moore Majority Vote algorithm modified for 2 candidates, achieving O(n) time and O(1) space complexity.

Common Approaches

✓ Dp 1d

⏱️ Time: N/A Space: N/A

Boyer-Moore Majority Vote - Optimal

⏱️ Time: O(n) Space: O(1)

Since at most 2 elements can appear more than n/3 times, use modified Boyer-Moore to track 2 candidates. First pass finds candidates, second pass verifies their actual counts.

Brute Force - Count Each Element

⏱️ Time: O(n²) Space: O(n)

For every unique element in the array, iterate through the entire array to count how many times it appears. If count > n/3, add it to result.

Hash Map - Two Pass Count

⏱️ Time: O(n) Space: O(n)

First pass through array builds a frequency map counting occurrences of each element. Second pass checks which elements have count > n/3.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int* nums, int numsSize) {
    int maxLength = 0;
    
    // Try each possible starting value for consecutive sequence
    int minVal = nums[0], maxVal = nums[0];
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < minVal) minVal = nums[i];
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    for (int start = minVal; start <= maxVal + 1; start++) {
        int length = 0;
        int* available = (int*)malloc(numsSize * sizeof(int));
        int availableSize = numsSize;
        for (int i = 0; i < numsSize; i++) {
            available[i] = nums[i];
        }
        
        // Try to build consecutive sequence starting from 'start'
        int current = start;
        while (1) {
            int found = 0;
            // Try to find an element that can become 'current'
            for (int i = 0; i < availableSize; i++) {
                if (available[i] == current || available[i] == current - 1) {
                    // Remove element by shifting
                    for (int j = i; j < availableSize - 1; j++) {
                        available[j] = available[j + 1];
                    }
                    availableSize--;
                    found = 1;
                    length++;
                    break;
                }
            }
            
            if (!found) {
                break;
            }
            current++;
        }
        
        if (length > maxLength) {
            maxLength = length;
        }
        
        free(available);
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int size = 0;
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

78.9K Views

Medium Frequency

~25 min Avg. Time

2.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen