GeeksforGeeks App
Open App
Browser
Continue

# Python3 Program for Check for Majority Element in a sorted array

Question: Write a function to find if a given integer x appears more than n/2 times in a sorted array of n integers.
Basically, we need to write a function say isMajority() that takes an array (arr[] ), array’s size (n) and a number to be searched (x) as parameters and returns true if x is a majority element (present more than n/2 times).

Examples:

```Input: arr[] = {1, 2, 3, 3, 3, 3, 10}, x = 3
Output: True (x appears more than n/2 times in the given array)

Input: arr[] = {1, 1, 2, 4, 4, 4, 6, 6}, x = 4
Output: False (x doesn't appear more than n/2 times in the given array)

Input: arr[] = {1, 1, 1, 2, 2}, x = 1
Output: True (x appears more than n/2 times in the given array)```

METHOD 1 (Using Linear Search)
Linearly search for the first occurrence of the element, once you find it (let at index i), check element at index i + n/2. If element is present at i+n/2 then return 1 else return 0.

## Python3

 `'''Python3 Program to check for majority element in a sorted array'''` `def` `isMajority(arr, n, x):``    ``# get last index according to n (even or odd) */``    ``last_index ``=` `(n``/``/``2` `+` `1``) ``if` `n ``%` `2` `=``=` `0` `else` `(n``/``/``2``)` `    ``# search for first occurrence of x in arr[]*/``    ``for` `i ``in` `range``(last_index):``        ``# check if x is present and is present more than n / 2 times */``        ``if` `arr[i] ``=``=` `x ``and` `arr[i ``+` `n``/``/``2``] ``=``=` `x:``            ``return` `1` `# Driver program to check above function */``arr ``=` `[``1``, ``2``, ``3``, ``4``, ``4``, ``4``, ``4``]``n ``=` `len``(arr)``x ``=` `4``if` `(isMajority(arr, n, x)):``    ``print` `(``"% d appears more than % d times in arr[]"``                                            ``%``(x, n``/``/``2``))``else``:``    ``print` `(``"% d does not appear more than % d times in arr[]"``                                                    ``%``(x, n``/``/``2``))`  `# This code is contributed by shreyanshi_arun.`

Output

` 4 does not appear more than  3 times in arr[]`

Time Complexity: O(n)
Auxiliary Space: O(1)

METHOD 2 (Using Binary Search)
Use binary search methodology to find the first occurrence of the given number. The criteria for binary search is important here.

## Python3

 `'''Python3 Program to check for majority element in a sorted array'''` `# This function returns true if the x is present more than n / 2``# times in arr[] of size n */``def` `isMajority(arr, n, x):``    ` `    ``# Find the index of first occurrence of x in arr[] */``    ``i ``=` `_binarySearch(arr, ``0``, n``-``1``, x)` `    ``# If element is not present at all, return false*/``    ``if` `i ``=``=` `-``1``:``        ``return` `False` `    ``# check if the element is present more than n / 2 times */``    ``if` `((i ``+` `n``/``/``2``) <``=` `(n ``-``1``)) ``and` `arr[i ``+` `n``/``/``2``] ``=``=` `x:``        ``return` `True``    ``else``:``        ``return` `False` `# If x is present in arr[low...high] then returns the index of``# first occurrence of x, otherwise returns -1 */``def` `_binarySearch(arr, low, high, x):``    ``if` `high >``=` `low:``        ``mid ``=` `(low ``+` `high)``/``/``2` `# low + (high - low)//2;` `        ``''' Check if arr[mid] is the first occurrence of x.``            ``arr[mid] is first occurrence if x is one of the following``            ``is true:``            ``(i) mid == 0 and arr[mid] == x``            ``(ii) arr[mid-1] < x and arr[mid] == x'''``        ` `        ``if` `(mid ``=``=` `0` `or` `x > arr[mid``-``1``]) ``and` `(arr[mid] ``=``=` `x):``            ``return` `mid``        ``elif` `x > arr[mid]:``            ``return` `_binarySearch(arr, (mid ``+` `1``), high, x)``        ``else``:``            ``return` `_binarySearch(arr, low, (mid ``-``1``), x)``    ``return` `-``1`  `# Driver program to check above functions */``arr ``=` `[``1``, ``2``, ``3``, ``3``, ``3``, ``3``, ``10``]``n ``=` `len``(arr)``x ``=` `3``if` `(isMajority(arr, n, x)):``    ``print` `(``"% d appears more than % d times in arr[]"``                                            ``%` `(x, n``/``/``2``))``else``:``    ``print` `(``"% d does not appear more than % d times in arr[]"``                                                    ``%` `(x, n``/``/``2``))` `# This code is contributed by shreyanshi_arun.`

Output

` 3 appears more than  3 times in arr[]`

Time Complexity: O(Log n)
Auxiliary Space: O(1)

METHOD 3: If it is already given that the array is sorted and there exists a majority element, checking if a particular element is as easy as checking if the middle element of the array is the number we are checking against.

Since a majority element occurs more than n/2 times in an array, it will always be the middle element. We can use this logic to check if the given number is the majority element.

## Python3

 `def` `isMajorityElement(arr,``                      ``n, key):` `   ``if` `(arr[n ``/``/` `2``] ``=``=` `key):``        ``return` `True``    ` `   ``return` `False` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1``, ``2``, ``3``, ``3``,``           ``3``, ``3``, ``10``]``    ``n ``=` `len``(arr)``    ``x ``=` `3``    ` `    ``if` `(isMajorityElement(arr, n, x)):``        ``print``(x, ``" appears more than "``,``              ``n ``/``/` `2` `, ``" times in arr[]"``)``    ``else``:``        ``print``(x, ``" does not appear more than"``,``              ``n ``/``/` `2``, ``" times in arr[]"``)` `# This code is contributed by Chitranayal`

Output

`3  appears more than  3  times in arr[]`

Time Complexity: O(1)
Auxiliary Space: O(1)

Please refer complete article on Check for Majority Element in a sorted array for more details!

### Using Binary Search:

Approach:

Since the array is sorted, we can perform a binary search to find the first occurrence and last occurrence of the given element. Then we can check if the count of occurrences is greater than n/2.

Define a binary_search function that takes the sorted array arr, the element to be searched x, and a boolean value search_first indicating whether to search for the first occurrence or the last occurrence of x in arr.

Initialize low and high as the first and last indices of arr.

Initialize a variable result to -1 to keep track of the index of the first or last occurrence of x.

Use a while loop to perform binary search on arr until low becomes greater than high.

In each iteration of the loop, calculate the mid index as the average of low and high.

If the element at index mid is equal to x, then set result to mid and update low and high based on the value of search_first.

If the element at index mid is less than x, then set low to mid + 1.

If the element at index mid is greater than x, then set high to mid – 1.

Return the value of result.

In the is_majority_element function, use binary_search to find the first and last occurrences of x in arr.

Calculate the count of occurrences of x as last_index – first_index + 1.

If the count is greater than len(arr) / 2, then return True indicating that x is the majority element. Otherwise, return False.

## Python3

 `def` `binary_search(arr, x, search_first):``    ``low ``=` `0``    ``high ``=` `len``(arr) ``-` `1``    ``result ``=` `-``1``    ``while` `low <``=` `high:``        ``mid ``=` `(low ``+` `high) ``/``/` `2``        ``if` `arr[mid] ``=``=` `x:``            ``result ``=` `mid``            ``if` `search_first:``                ``high ``=` `mid ``-` `1``            ``else``:``                ``low ``=` `mid ``+` `1``        ``elif` `arr[mid] < x:``            ``low ``=` `mid ``+` `1``        ``else``:``            ``high ``=` `mid ``-` `1``    ``return` `result` `def` `is_majority_element(arr, x):``    ``first_index ``=` `binary_search(arr, x, ``True``)``    ``last_index ``=` `binary_search(arr, x, ``False``)``    ``count ``=` `last_index ``-` `first_index ``+` `1``    ``if` `count > ``len``(arr) ``/` `2``:``        ``return` `True``    ``else``:``        ``return` `False``arr1 ``=` `[``1``, ``2``, ``3``, ``3``, ``3``, ``3``, ``10``]``x1 ``=` `3``print``(is_majority_element(arr1, x1)) ``# Output: True` `arr2 ``=` `[``1``, ``1``, ``2``, ``4``, ``4``, ``4``, ``6``, ``6``]``x2 ``=` `4``print``(is_majority_element(arr2, x2)) ``# Output: False` `arr3 ``=` `[``1``, ``1``, ``1``, ``2``, ``2``]``x3 ``=` `1``print``(is_majority_element(arr3, x3)) ``# Output: True`

Output

```True
False
True```

Time Complexity: O(log n)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up