Majority Element - Practice Coding Problems

Majority Element - Problem

Given an array nums of size n, find and return the majority element.

The majority element is defined as the element that appears more than ⌊n / 2⌋ times. In other words, it appears in more than half of the array positions.

Key points:

You can assume that the majority element always exists in the array
There is always exactly one majority element
The majority element appears more than n/2 times, making it the most frequent element

Example: In array [3,2,3], element 3 appears 2 times out of 3 total elements. Since 2 > 3/2 = 1.5, element 3 is the majority element.

Input & Output

example_1.py — Basic Majority

$ Input: [3,2,3]

› Output: 3

💡 Note: Element 3 appears 2 times out of 3 total elements. Since 2 > 3/2 = 1.5, element 3 is the majority element.

example_2.py — Larger Array

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

› Output: 2

💡 Note: Element 2 appears 4 times out of 7 total elements. Since 4 > 7/2 = 3.5, element 2 is the majority element.

example_3.py — Single Element

$ Input: [1]

› Output: 1

💡 Note: With only one element, it automatically becomes the majority element since 1 > 1/2 = 0.5.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Count Frequencies

Track how many times each element appears in the array

Calculate Threshold

Majority threshold is n/2, element must appear more than this

Find Winner

Return the element whose count exceeds the majority threshold

Key Takeaway

🎯 Key Insight: The majority element appears more than n/2 times, so counting frequencies and comparing against n/2 threshold efficiently identifies the winner.

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses a hash table with single pass to count element frequencies and identify the majority element in O(n) time. For space-optimal solution, consider the Boyer-Moore Voting Algorithm which achieves O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Table (One Pass Optimized)	O(n)	O(n)	Count elements and check for majority in a single pass
Hash Table (Two Pass)	O(n)	O(n)	Count all elements in hash map, then find the majority element
Brute Force (Count Each Element)	O(n²)	O(1)	For each element, count its occurrences in the entire array

Hash Table (One Pass Optimized) — Algorithm Steps

Calculate majority threshold (n/2) upfront
Iterate through array once, counting each element
After incrementing count, immediately check if it exceeds n/2
Return element as soon as majority condition is met

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Element

Increment count for current element in hash map

Immediate Check

Check if new count exceeds n/2 threshold

Early Return

Return immediately when majority is found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#define MAX_ELEMENTS 1000

int majorityElement(int* nums, int numsSize) {
    int values[MAX_ELEMENTS];
    int counts[MAX_ELEMENTS];
    int unique = 0;
    int majorityCount = numsSize / 2;
    
    for (int i = 0; i < numsSize; i++) {
        int found = 0;
        
        // Check if element already exists
        for (int j = 0; j < unique; j++) {
            if (values[j] == nums[i]) {
                counts[j]++;
                // Check immediately after incrementing
                if (counts[j] > majorityCount) {
                    return nums[i];
                }
                found = 1;
                break;
            }
        }
        
        // Add new element
        if (!found) {
            values[unique] = nums[i];
            counts[unique] = 1;
            if (1 > majorityCount) {
                return nums[i];
            }
            unique++;
        }
    }
    
    return -1;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    char* ptr = line + 1;
    
    while (*ptr != ']' && *ptr != '\0') {
        nums[size++] = strtol(ptr, &ptr, 10);
        if (*ptr == ',') ptr++;
    }
    
    int result = majorityElement(nums, size);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, with potential early termination when majority is found

✓ Linear Growth

Space Complexity

O(n)

Hash map stores frequencies, worst case stores all n elements if all are unique

⚡ Linearithmic Space

127.6K Views

High Frequency

~15 min Avg. Time

2.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

Hash Table (One Pass Optimized) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler