C# Program to Check for Majority Element in a sorted array
Last Updated :
22 May, 2023
Problem Statement: 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[] ), the 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 the element at index i + n/2. If the element is present at i+n/2 then return 1 else return 0.
C#
// C# Program to check for majority
// element in a sorted array
using System;
class GFG {
static bool isMajority(int[] arr,
int n, int x)
{
int i, last_index = 0;
// Get last index according to
// n (even or odd)
last_index = (n % 2 == 0) ? n / 2 :
n / 2 + 1;
// Search for first occurrence
// of x in arr[]
for (i = 0; i < last_index; i++) {
// Check if x is present and
// is present more than n/2 times
if (arr[i] == x && arr[i + n / 2] == x)
return true;
}
return false;
}
// Driver code
public static void Main()
{
int[] arr = { 1, 2, 3, 4, 4, 4, 4 };
int n = arr.Length;
int x = 4;
if (isMajority(arr, n, x) == true)
Console.Write(x + " appears more than " +
n / 2 + " times in arr[]");
else
Console.Write(x + " does not appear more than " +
n / 2 + " times in arr[]");
}
}
// This code is contributed by Sam007
Output:
4 appears more than 3 times in arr[]
Time Complexity: O(n)
Auxiliary Space: O(1), as constant extra space is used.
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.
C#
// C# Program to check for majority
// element in a sorted array */
using System;
class GFG {
// If x is present in arr[low...high]
// then returns the index of first
// occurrence of x, otherwise returns -1
static int _binarySearch(int[] arr, int low, int high,
int x)
{
if (high >= low) {
int 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 || x > arr[mid - 1])
&& (arr[mid] == x))
return mid;
else if (x > arr[mid])
return _binarySearch(arr, (mid + 1), high,
x);
else
return _binarySearch(arr, low, (mid - 1),
x);
}
return -1;
}
// This function returns true if the x is
// present more than n/2 times in arr[]
// of size n
static bool isMajority(int[] arr, int n, int x)
{
// Find the index of first occurrence
// of x in arr[]
int 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)) && arr[i + n / 2] == x)
return true;
else
return false;
}
// Driver code
public static void Main()
{
int[] arr = { 1, 2, 3, 3, 3, 3, 10 };
int n = arr.Length;
int x = 3;
if (isMajority(arr, n, x) == true)
Console.Write(x + " appears more than " + n / 2
+ " times in arr[]");
else
Console.Write(x + " does not appear more than "
+ n / 2 + " times in arr[]");
}
}
// This code is contributed by Sam007
Output:
3 appears more than 3 times in arr[]
Time Complexity: O(Logn)
Auxiliary Space: O(1), as constant extra space is used.
Method 3: Divide and Conquer
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.
C#
using System;
// Class
class GFG {
// Method to find majority element
static bool isMajorityElement(int[] arr, int n, int key)
{
if (arr[n / 2] == key)
return true;
else
return false;
}
// Driver Code
public static void Main(String[] args)
{
// Custom input array
int[] arr = { 1, 2, 3, 3, 3, 3, 10 };
int n = arr.Length;
int x = 3;
if (isMajorityElement(arr, n, x))
Console.Write(x + " appears more than " + n / 2
+ " times in []arr");
else
Console.Write(x + " does not appear more "
+ "than " + n / 2
+ " times in arr[]");
}
}
// This code is contributed by aashish1995
Output3 appears more than 3 times in arr[]
Time complexity: O(1)
Auxiliary Space: O(1)
Method 4: Using Moore’s Voting Algorithm
- Initialize the candidate element as the first element of the array setting count to 1.
- Traverse through the array from the second element to the last.
- If the current element is the same as the candidate element, increment the count otherwise decrement the count.
- If the count becomes 0, set the current element as the candidate element and reset the count to 1.
- Check if the candidate element is the majority element by traversing the array again and counting the number of occurrences of the candidate element.
- If the number of occurrences of the candidate element is greater than n/2, return the candidate element. Otherwise, return -1.
C#
using System;
// Class
class Program {
// Method to find majority
static int FindMajority(int[] arr, int n)
{
// Initialize candidate as first element
int candidate = arr[0];
int count = 1;
// Find majority element
for (int i = 1; i < n; i++) {
if (arr[i] == candidate)
count++;
else
count--;
if (count == 0) {
candidate = arr[i];
count = 1;
}
}
// Checking if candidate is the majority element
int countCandidate = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == candidate)
countCandidate++;
}
if (countCandidate > n / 2)
return candidate;
else
return -1;
}
// Driver method
static void Main()
{
// Custom input array
int[] arr = { 1, 2, 3, 3, 3, 3, 10 };
int n = arr.Length;
int majorityElement = FindMajority(arr, n);
// Printing the majority element
// it is found
if (majorityElement != -1)
Console.Write(majorityElement
+ " is the majority element");
else
// Display message there exists no majority
// element
Console.Write("No majority element");
}
}
Output3 is the majority element
Time complexity is O(n)
Auxiliary Space: O(n)
Please refer complete article on Check for Majority Element in a sorted array for more details!
Similar Reads
Check for Majority Element in a sorted array Given an array arr of N elements, A majority element in an array arr of size N is an element that appears more than N/2 times in the array. The task is 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 i
15+ min read
Javascript Program to Check 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 majorit
3 min read
Check whether a given array is a k sorted array or not Given an array of n distinct elements. Check whether the given array is a k sorted array or not. A k sorted array is an array where each element is at most k distances away from its target position in the sorted array. For example, let us consider k is 2, an element at index 7 in the sorted array, c
12 min read
Count of smaller or equal elements in sorted array Given a sorted array of size n. Find a number of elements that are less than or equal to a given element. Examples: Input : arr[] = {1, 2, 4, 5, 8, 10} key = 9 Output : 5 Elements less than or equal to 9 are 1, 2, 4, 5, 8 therefore result will be 5. Input : arr[] = {1, 2, 2, 2, 5, 7, 9} key = 2 Outp
15+ min read
Search an element in a reverse sorted array Given an array arr[] sorted in decreasing order, and an integer X, the task is to check if X is present in the given array or not. If X is present in the array, print its index ( 0-based indexing). Otherwise, print -1. Examples: Input: arr[] = {5, 4, 3, 2, 1}, X = 4Output: 1Explanation: Element X (=
8 min read
Count elements less than or equal to a given value in a sorted rotated array Given a sorted array of n distinct integers rotated at some point. Given a value x. The problem is to count all the elements in the array which are less than or equal to x. Examples: Input : arr[] = {4, 5, 8, 1, 3}, x = 6 Output : 4 Input : arr[] = {6, 10, 12, 15, 2, 4, 5}, x = 14 Output : 6 Naive A
15 min read