Majority Element II - Practice Coding Problems

Majority Element II - Problem

You're given an integer array of size n, and your mission is to find all the truly dominant elements - those that appear more than ⌊n/3⌋ times.

This is a step up from the classic "Majority Element" problem where we looked for elements appearing more than ⌊n/2⌋ times. Here, we're looking for elements that appear in more than one-third of the array positions.

Key insight: There can be at most 2 elements that satisfy this condition in any array. Why? If three elements each appeared more than n/3 times, their total count would exceed n, which is impossible!

Example: In array [3,2,3] with n=3, we need elements appearing more than ⌊3/3⌋ = 1 time. Element 3 appears 2 times, so it's a majority element.

Input & Output

example_1.py — Basic Case

$ Input: [3,2,3]

› Output: [3]

💡 Note: Array length n=3, so threshold = ⌊3/3⌋ = 1. Element 3 appears 2 times > 1, element 2 appears 1 time ≤ 1. Only 3 qualifies.

example_2.py — Multiple Majority

$ Input: [1,1,1,3,3,2,2,2]

› Output: [1,2]

💡 Note: Array length n=8, so threshold = ⌊8/3⌋ = 2. Element 1 appears 3 times > 2, element 2 appears 3 times > 2, element 3 appears 2 times ≤ 2. Elements 1 and 2 qualify.

example_3.py — No Majority

$ Input: [1,2,3,4,5,6]

› Output: []

💡 Note: Array length n=6, so threshold = ⌊6/3⌋ = 2. Each element appears only once, which is ≤ 2. No elements qualify as majority.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
Follow-up: Could you solve the problem in linear time and in O(1) space?

Visualization

Tap to expand

Understanding the Visualization

Campaign Phase

Two candidates compete for support, gaining and losing votes

Vote Counting

When conflicts arise, both candidates lose support (like negative campaigning)

Final Tally

After campaigning, we verify which candidates actually have >n/3 votes

Winners Declared

Only verified candidates with sufficient support are declared winners

Key Takeaway

🎯 Key Insight: Just like in elections, at most 2 candidates can win when each needs >1/3 support, since 3 winners would need >100% total votes!

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses the Boyer-Moore Voting Algorithm with O(n) time and O(1) space. Key insight: at most 2 elements can appear more than n/3 times. The algorithm has two phases: voting phase to find 2 potential candidates, and verification phase to confirm they actually exceed the threshold.

Common Approaches

Approach	Time	Space	Notes
✓ Boyer-Moore Voting Algorithm	O(n)	O(1)	Optimal O(1) space solution using modified Boyer-Moore algorithm for two candidates
Brute Force (Nested Loops)	O(n²)	O(k)	For each element, count its occurrences by scanning the entire array
Hash Table Counting	O(n)	O(n)	Count all elements using hash table, then filter those exceeding n/3

Boyer-Moore Voting Algorithm — Algorithm Steps

Initialize two candidates and their vote counts to 0
First pass: voting phase to find potential candidates
If current element matches candidate1, increment its count
Else if current element matches candidate2, increment its count
Else if candidate1 has 0 votes, make current element candidate1
Else if candidate2 has 0 votes, make current element candidate2
Else decrement both candidate counts (voting against both)
Second pass: verify candidates actually exceed n/3 threshold

Visualization

Tap to expand

Step-by-Step Walkthrough

Voting Phase

Maintain two candidates and their vote counts

Vote Management

Increment matching candidates, decrement on conflicts

Verification Phase

Count actual occurrences of candidates

Code -

solution.c — C

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

int* majorityElement(int* nums, int numsSize, int* returnSize) {
    if (numsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    // Phase 1: Find potential candidates
    int candidate1 = 0, candidate2 = 0;
    int count1 = 0, count2 = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (count1 > 0 && nums[i] == candidate1) {
            count1++;
        } else if (count2 > 0 && nums[i] == candidate2) {
            count2++;
        } else if (count1 == 0) {
            candidate1 = nums[i];
            count1 = 1;
        } else if (count2 == 0) {
            candidate2 = nums[i];
            count2 = 1;
        } else {
            count1--;
            count2--;
        }
    }
    
    // Phase 2: Verify candidates
    int threshold = numsSize / 3;
    int* result = (int*)malloc(2 * sizeof(int));
    *returnSize = 0;
    
    count1 = count2 = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == candidate1) count1++;
        else if (nums[i] == candidate2) count2++;
    }
    
    if (count1 > threshold) {
        result[(*returnSize)++] = candidate1;
    }
    if (count2 > threshold) {
        result[(*returnSize)++] = candidate2;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array: O(n) for voting + O(n) for verification

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for two candidates and their counts

✓ Linear Space

52.4K Views

High Frequency

~18 min Avg. Time

1.8K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Boyer-Moore Voting Algorithm — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler