Check If a Number Is Majority Element in a Sorted Array

Check If a Number Is Majority Element in a Sorted Array - Problem

Given an integer array nums sorted in non-decreasing order and an integer target, determine if the target is a majority element in the array.

A majority element is an element that appears more than nums.length / 2 times in the array. In other words, it must appear in more than half of the array positions.

Key insight: Since the array is already sorted, all occurrences of the target (if any) will be grouped together consecutively. This property allows us to use efficient searching algorithms instead of counting each element.

Goal: Return true if target appears more than n/2 times, false otherwise.

Input & Output

example_1.py — Basic Majority Case

$ Input: nums = [2,4,5,5,5,5,5,6,6], target = 5

› Output: true

💡 Note: The target 5 appears 5 times in the array of length 9. Since 5 > 9/2 (4.5), it's a majority element.

example_2.py — Not Majority

$ Input: nums = [10,100,101,101], target = 101

› Output: false

💡 Note: The target 101 appears 2 times in the array of length 4. Since 2 = 4/2, it's not more than half, so not a majority element.

example_3.py — Target Not Found

$ Input: nums = [1,1,2,3,3,4,4], target = 5

› Output: false

💡 Note: The target 5 doesn't exist in the array, so it can't be a majority element.

Visualization

Tap to expand

Understanding the Visualization

Binary Search Left

Find the leftmost occurrence of the target using binary search

Binary Search Right

Find the rightmost occurrence of the target using binary search

Calculate Range

Count = right_index - left_index + 1

Check Majority

Return count > array_length / 2

Key Takeaway

🎯 Key Insight: Since the array is sorted, identical elements form consecutive groups. Binary search can efficiently find group boundaries in O(log n) time, making this much faster than O(n) linear counting!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must examine every element once to count occurrences

✓ Linear Growth

Space Complexity

O(1)

Only uses a single counter variable

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
-10⁹ ≤ nums[i], target ≤ 10⁹
nums is sorted in non-decreasing order

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 31

The optimal solution uses binary search to find the first and last occurrence of the target element in O(log n) time. Since the array is sorted, all occurrences of the target are consecutive. We calculate the count as last_position - first_position + 1 and check if it exceeds n/2. This approach is significantly more efficient than linear scanning for large arrays.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Count)	O(n)	O(1)	Scan entire array counting target occurrences
Binary Search (Optimal)	O(log n)	O(1)	Find first and last occurrence using binary search, then calculate range

Brute Force (Linear Count) — Algorithm Steps

Initialize a counter to 0
Iterate through each element in the array
Increment counter whenever we find the target
After scanning, check if count > nums.length / 2

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counter

Start with count = 0 and scan from left to right

Check Each Element

Compare each element with target and increment counter if match

Compare Final Count

Check if final count > array.length / 2

Code -

solution.c — C

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

bool isMajorityElement(int* nums, int numsSize, int target) {
    int count = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == target) {
            count++;
        }
    }
    return count > numsSize / 2;
}

int main() {
    int nums[1000];
    int numsSize = 0;
    int num;
    char ch;
    
    while (scanf("%d%c", &num, &ch)) {
        nums[numsSize++] = num;
        if (ch == '\n') break;
    }
    
    int target;
    scanf("%d", &target);
    
    printf("%s\n", isMajorityElement(nums, numsSize, target) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must examine every element once to count occurrences

✓ Linear Growth

Space Complexity

O(1)

Only uses a single counter variable

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
-10⁹ ≤ nums[i], target ≤ 10⁹
nums is sorted in non-decreasing order

38.2K Views

Medium Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Linear Count) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler