Write a function which takes an array and prints the majority element (if it exists), otherwise prints “No Majority Element”. A majority element in an array A[] of size n is an element that appears more than n/2 times (and hence there is at most one such element).

Examples :

Input : {3, 3, 4, 2, 4, 4, 2, 4, 4} Output : 4 Explanation: The frequency of 4 is 5 which is greater than the half of the size of the array size. Input : {3, 3, 4, 2, 4, 4, 2, 4} Output : No Majority Element Explanation: There is no element whose frequency is greater than the half of the size of the array size.



METHOD 1

Approach: The basic solution is to have two loops and keep track of the maximum count for all different elements. If maximum count becomes greater than n/2 then break the loops and return the element having maximum count. If the maximum count doesn’t become more than n/2 then majority element doesn’t exist.

The basic solution is to have two loops and keep track of the maximum count for all different elements. If maximum count becomes greater than n/2 then break the loops and return the element having maximum count. If the maximum count doesn’t become more than n/2 then majority element doesn’t exist. Algorithm: Create a variable to store the max count, count = 0 Traverse through the array from start to end. For every element in the array run another loop to find the count of similar elements in the given array. If the count is greater than the max count update the max count and store the index in another varaible. If the maximum count is greater than the half the size of the array, print the element. Else print there is no majority element.

Implementation:

C++ filter_none edit

close play_arrow link

brightness_4

code #include <bits/stdc++.h> using namespace std; void findMajority( int arr[], int n) { int maxCount = 0; int index = -1; for ( int i = 0; i < n; i++) { int count = 0; for ( int j = 0; j < n; j++) { if (arr[i] == arr[j]) count++; } if (count > maxCount) { maxCount = count; index = i; } } if (maxCount > n/2) cout << arr[index] << endl; else cout << "No Majority Element" << endl; } int main() { int arr[] = {1, 1, 2, 1, 3, 5, 1}; int n = sizeof (arr) / sizeof (arr[0]); findMajority(arr, n); return 0; } chevron_right filter_none Java filter_none edit

close play_arrow link

brightness_4

code import java.io.*; class GFG { static void findMajority( int arr[], int n) { int maxCount = 0 ; int index = - 1 ; for ( int i = 0 ; i < n; i++) { int count = 0 ; for ( int j = 0 ; j < n; j++) { if (arr[i] == arr[j]) count++; } if (count > maxCount) { maxCount = count; index = i; } } if (maxCount > n/ 2 ) System.out.println (arr[index]); else System.out.println ( "No Majority Element" ); } public static void main (String[] args) { int arr[] = { 1 , 1 , 2 , 1 , 3 , 5 , 1 }; int n = arr.length; findMajority(arr, n); } } chevron_right filter_none Python 3 filter_none edit

close play_arrow link

brightness_4

code def findMajority(arr, n): maxCount = 0 ; index = - 1 for i in range (n): count = 0 for j in range (n): if (arr[i] = = arr[j]): count + = 1 if (count > maxCount): maxCount = count index = i if (maxCount > n / / 2 ): print (arr[index]) else : print ( "No Majority Element" ) if __name__ = = "__main__" : arr = [ 1 , 1 , 2 , 1 , 3 , 5 , 1 ] n = len (arr) findMajority(arr, n) chevron_right filter_none C# filter_none edit

close play_arrow link

brightness_4

code using System; public class GFG{ static void findMajority( int []arr, int n) { int maxCount = 0; int index = -1; for ( int i = 0; i < n; i++) { int count = 0; for ( int j = 0; j < n; j++) { if (arr[i] == arr[j]) count++; } if (count > maxCount) { maxCount = count; index = i; } } if (maxCount > n/2) Console.WriteLine (arr[index]); else Console.WriteLine( "No Majority Element" ); } static public void Main (){ int []arr = {1, 1, 2, 1, 3, 5, 1}; int n = arr.Length; findMajority(arr, n); } } chevron_right filter_none PHP filter_none edit

close play_arrow link

brightness_4

code <?php function findMajority( $arr , $n ) { $maxCount = 0; $index = -1; for ( $i = 0; $i < $n ; $i ++) { $count = 0; for ( $j = 0; $j < $n ; $j ++) { if ( $arr [ $i ] == $arr [ $j ]) $count ++; } if ( $count > $maxCount ) { $maxCount = $count ; $index = $i ; } } if ( $maxCount > $n /2) echo $arr [ $index ] . "

" ; else echo "No Majority Element" . "

" ; } $arr = array (1, 1, 2, 1, 3, 5, 1); $n = sizeof( $arr ); findMajority( $arr , $n ); chevron_right filter_none

Output: 1

Compelxity Analysis: Time Complexity: O(n*n).

A nested loop is needed where both the loops traverse the array from start to end, so the time complexity is O(n^2). Auxiliary Space : O(1).

As no extra space is required for any operation so the space complexity is constant.





METHOD 2 (Using Binary Search Tree)

Approach: Insert elements in BST one by one and if an element is already present then increment the count of the node. At any stage, if the count of a node becomes more than n/2 then return.

Insert elements in BST one by one and if an element is already present then increment the count of the node. At any stage, if the count of a node becomes more than n/2 then return. Algorithm: Create a binary search tree, if same element is entered in the binary search tree the frequency of the node is increased. traverse the array and insert the element in the binary search tree. If the maximum frequency of any node is greater than the half the size of the array, then perform a inorder traversal and find the node with frequency greater than half Else print No majority Element.

Implementation:



filter_none edit

close play_arrow link

brightness_4

code #include<bits/stdc++.h> using namespace std; struct node { int key; int c = 0; struct node *left, *right; }; struct node *newNode( int item) { struct node *temp = ( struct node *) malloc ( sizeof ( struct node)); temp->key = item; temp->c = 1; temp->left = temp->right = NULL; return temp; } struct node* insert( struct node* node, int key, int &ma) { if (node == NULL) { if (ma==0) ma=1; return newNode(key); } if (key < node->key) node->left = insert(node->left, key, ma); else if (key > node->key) node->right = insert(node->right, key, ma); else node->c++; ma = max(ma, node->c); return node; } void inorder( struct node *root, int s) { if (root != NULL) { inorder(root->left,s); if (root->c>(s/2)) printf ( "%d

" , root->key); inorder(root->right,s); } } int main() { int a[] = {1, 3, 3, 3, 2}; int size = ( sizeof (a))/ sizeof (a[0]); struct node *root = NULL; int ma=0; for ( int i=0;i<size;i++) { root = insert(root, a[i],ma); } if (ma>(size/2)) inorder(root,size); else cout<< "No majority element

" ; return 0; } chevron_right filter_none Output: 3

Compelxity Analysis: Time Complexity : If a Binary Search Tree is used then time complexity will be O(n^2). If a self-balancing-binary-search tree is used then it will be O(nlogn) Auxiliary Space : O(n).

As extra space is needed to store the array in tree.



METHOD 3 (Using Moore’s Voting Algorithm):

Approach: This is a two-step process. The first step gives the element that maybe the majority element in the array. If there is a majority element in an array, then this step will definitely return majority element, otherwise, it will return candidate for majority element.

Check if the element obtained from the above step is majority element. This step is necessary as there might be no majority element. Step 1: Finding a Candidate

The algorithm for the first phase that works in O(n) is known as Moore’s Voting Algorithm. Basic idea of the algorithm is that if each occurrence of an element e can be cancelled with all the other elements that are different from e then e will exist till end if it is a majority element. Step 2: Check if the element obtained in step 1 is majority element or not.

Traverse through the array and check if the count of the element found is greater than half the size of the array, then print the answer else print “No majority element”.

Algorithm: Loop through each element and maintains a count of majority element, and a majority index, maj_index If the next element is same then increment the count if the next element is not same then decrement the count. if the count reaches 0 then changes the maj_index to the current element and set the count again to 1. Now again traverse through the array and find the count of majority element found. If the count is greater than half the size of the array, print the element Else print that there is no majority element

Implementation:

C++ filter_none edit

close play_arrow link

brightness_4

code #include <bits/stdc++.h> using namespace std; int findCandidate( int a[], int size) { int maj_index = 0, count = 1; for ( int i = 1; i < size; i++) { if (a[maj_index] == a[i]) count++; else count--; if (count == 0) { maj_index = i; count = 1; } } return a[maj_index]; } bool isMajority( int a[], int size, int cand) { int count = 0; for ( int i = 0; i < size; i++) if (a[i] == cand) count++; if (count > size/2) return 1; else return 0; } void printMajority( int a[], int size) { int cand = findCandidate(a, size); if (isMajority(a, size, cand)) cout << " " << cand << " " ; else cout << "No Majority Element" ; } int main() { int a[] = {1, 3, 3, 1, 2}; int size = ( sizeof (a))/ sizeof (a[0]); printMajority(a, size); return 0; } chevron_right filter_none C filter_none edit

close play_arrow link

brightness_4

code # include<stdio.h> # define bool int int findCandidate( int *, int ); bool isMajority( int *, int , int ); void printMajority( int a[], int size) { int cand = findCandidate(a, size); if (isMajority(a, size, cand)) printf ( " %d " , cand); else printf ( "No Majority Element" ); } int findCandidate( int a[], int size) { int maj_index = 0, count = 1; int i; for (i = 1; i < size; i++) { if (a[maj_index] == a[i]) count++; else count--; if (count == 0) { maj_index = i; count = 1; } } return a[maj_index]; } bool isMajority( int a[], int size, int cand) { int i, count = 0; for (i = 0; i < size; i++) if (a[i] == cand) count++; if (count > size/2) return 1; else return 0; } int main() { int a[] = {1, 3, 3, 1, 2}; int size = ( sizeof (a))/ sizeof (a[0]); printMajority(a, size); getchar (); return 0; } chevron_right filter_none Java filter_none edit

close play_arrow link

brightness_4

code class MajorityElement { void printMajority( int a[], int size) { int cand = findCandidate(a, size); if (isMajority(a, size, cand)) System.out.println( " " + cand + " " ); else System.out.println( "No Majority Element" ); } int findCandidate( int a[], int size) { int maj_index = 0 , count = 1 ; int i; for (i = 1 ; i < size; i++) { if (a[maj_index] == a[i]) count++; else count--; if (count == 0 ) { maj_index = i; count = 1 ; } } return a[maj_index]; } boolean isMajority( int a[], int size, int cand) { int i, count = 0 ; for (i = 0 ; i < size; i++) { if (a[i] == cand) count++; } if (count > size / 2 ) return true ; else return false ; } public static void main(String[] args) { MajorityElement majorelement = new MajorityElement(); int a[] = new int []{ 1 , 3 , 3 , 1 , 2 }; int size = a.length; majorelement.printMajority(a, size); } } chevron_right filter_none Python filter_none edit

close play_arrow link

brightness_4

code def findCandidate(A): maj_index = 0 count = 1 for i in range ( len (A)): if A[maj_index] = = A[i]: count + = 1 else : count - = 1 if count = = 0 : maj_index = i count = 1 return A[maj_index] def isMajority(A, cand): count = 0 for i in range ( len (A)): if A[i] = = cand: count + = 1 if count > len (A) / 2 : return True else : return False def printMajority(A): cand = findCandidate(A) if isMajority(A, cand) = = True : print (cand) else : print ( "No Majority Element" ) A = [ 1 , 3 , 3 , 1 , 2 ] printMajority(A) chevron_right filter_none C# filter_none edit

close play_arrow link

brightness_4

code using System; class GFG { static void printMajority( int []a, int size) { int cand = findCandidate(a, size); if (isMajority(a, size, cand)) Console.Write( " " + cand + " " ); else Console.Write( "No Majority Element" ); } static int findCandidate( int []a, int size) { int maj_index = 0, count = 1; int i; for (i = 1; i < size; i++) { if (a[maj_index] == a[i]) count++; else count--; if (count == 0) { maj_index = i; count = 1; } } return a[maj_index]; } static bool isMajority( int []a, int size, int cand) { int i, count = 0; for (i = 0; i < size; i++) { if (a[i] == cand) count++; } if (count > size / 2) return true ; else return false ; } public static void Main() { int []a = {1, 3, 3, 1, 2}; int size = a.Length; printMajority(a, size); } } chevron_right filter_none PHP filter_none edit

close play_arrow link

brightness_4

code <?php function findCandidate( $a , $size ) { $maj_index = 0; $count = 1; for ( $i = 1; $i < $size ; $i ++) { if ( $a [ $maj_index ] == $a [ $i ]) $count ++; else $count --; if ( $count == 0) { $maj_index = $i ; $count = 1; } } return $a [ $maj_index ]; } function isMajority( $a , $size , $cand ) { $count = 0; for ( $i = 0; $i < $size ; $i ++) if ( $a [ $i ] == $cand ) $count ++; if ( $count > $size / 2) return 1; else return 0; } function printMajority( $a , $size ) { $cand = findCandidate( $a , $size ); if (isMajority( $a , $size , $cand )) echo " " , $cand , " " ; else echo "No Majority Element" ; } $a = array (1, 3, 3, 1, 2); $size = sizeof( $a ); printMajority( $a , $size ); ?> chevron_right filter_none

Output: No Majority Element

Complexity Analysis:



Time Complexity: O(n).

As two traversal of the array is needed, so the time complexity is linear.

O(n). As two traversal of the array is needed, so the time complexity is linear. Auxiliary Space : O(1).

As no extra space is required.



METHOD 4 (Using Hashmap):

Approach: This method is somewhat similar to Moore voting algorithm in terms of time complexity, but in this case, there is no need for the second step of Moore voting algorithm. But as usual, here space complexity becomes O(n).

In Hashmap(key-value pair), at value, maintain a count for each element(key) and whenever the count is greater than half of the array length, return that key(majority element).

This method is somewhat similar to Moore voting algorithm in terms of time complexity, but in this case, there is no need for the second step of Moore voting algorithm. But as usual, here space complexity becomes O(n). In Hashmap(key-value pair), at value, maintain a count for each element(key) and whenever the count is greater than half of the array length, return that key(majority element). Algorithm: Create a hashmap to store a key-value pair, i.e. element-frequency pair. Traverse the array from start to end. For every element in the array, insert the element in the hashmap if the element does not exist as key, else fetch the value of the key ( array[i] ) and increase the value by 1 If the count is greater than half then print the majority element and break. If no majority element is found print “No Majority element”

Implementation:

C++ filter_none edit

close play_arrow link

brightness_4

code #include <bits/stdc++.h> using namespace std; void findMajority( int arr[], int size) { unordered_map< int , int > m; for ( int i = 0; i < size; i++) m[arr[i]]++; int count = 0; for ( auto i : m) { if (i.second > size / 2) { count =1; cout << "Majority found :- " << i.first<<endl; break ; } } if (count == 0) cout << "No Majority element" << endl; } int main() { int arr[] = {2, 2, 2, 2, 5, 5, 2, 3, 3}; int n = sizeof (arr) / sizeof (arr[0]); findMajority(arr, n); return 0; } chevron_right filter_none Java filter_none edit

close play_arrow link

brightness_4

code import java.util.HashMap; class MajorityElement { private static void findMajority( int [] arr) { HashMap<Integer,Integer> map = new HashMap<Integer, Integer>(); for ( int i = 0 ; i < arr.length; i++) { if (map.containsKey(arr[i])) { int count = map.get(arr[i]) + 1 ; if (count > arr.length / 2 ) { System.out.println( "Majority found :- " + arr[i]); return ; } else map.put(arr[i], count); } else map.put(arr[i], 1 ); } System.out.println( " No Majority element" ); } public static void main(String[] args) { int a[] = new int []{ 2 , 2 , 2 , 2 , 5 , 5 , 2 , 3 , 3 }; findMajority(a); } } chevron_right filter_none Python3 filter_none edit

close play_arrow link

brightness_4

code def findMajority(arr, size): m = {} for i in range (size): if arr[i] in m: m[arr[i]] + = 1 else : m[arr[i]] = 1 count = 0 for key in m: if m[key] > size / 2 : count = 1 print ( "Majority found :-" ,key) break if (count = = 0 ): print ( "No Majority element" ) arr = [ 2 , 2 , 2 , 2 , 5 , 5 , 2 , 3 , 3 ] n = len (arr) findMajority(arr, n) chevron_right filter_none C# filter_none edit

close play_arrow link

brightness_4

code using System; using System.Collections.Generic; class GFG { private static void findMajority( int [] arr) { Dictionary< int , int > map = new Dictionary< int , int >(); for ( int i = 0; i < arr.Length; i++) { if (map.ContainsKey(arr[i])) { int count = map[arr[i]] + 1; if (count > arr.Length / 2) { Console.WriteLine( "Majority found :- " + arr[i]); return ; } else { map[arr[i]] = count; } } else { map[arr[i]] = 1; } } Console.WriteLine( " No Majority element" ); } public static void Main( string [] args) { int [] a = new int []{2, 2, 2, 2, 5, 5, 2, 3, 3}; findMajority(a); } } chevron_right filter_none Output: Majority found :- 2 Thanks Ashwani Tanwar, Karan Malhotra for suggesting this.

Complexity Analysis: Time Complexity: O(n).

One traversal of the array is needed, so the time complexity is linear. Auxiliary Space : O(n).

Since a hashmap requires linear space.



METHOD 5

Approach: The idea is to sort the array. Sorting makes similar elements in the array adjacent, so traverse the array and update the count until the present element is similar to the previous one. If the frequency is more than half the size of the array, print the majority element.

The idea is to sort the array. Sorting makes similar elements in the array adjacent, so traverse the array and update the count until the present element is similar to the previous one. If the frequency is more than half the size of the array, print the majority element. Algorithm: Sort the array and create a varibale count and previous , prev = INT_MIN . Traverse the element from start to end. If the current element is equal to the previous element increase the count. Else set the count to 1. If the count is greater than half the size of array, print the element as majority element and break. If no majority element found, print “No majority element”

Implementation: filter_none edit

close play_arrow link

brightness_4

code #include <bits/stdc++.h> using namespace std; int majorityElement( int *arr, int n) { sort(arr, arr+n); int count = 1, max_ele = -1, temp = arr[0], ele, f=0; for ( int i=1;i<n;i++) { if (temp==arr[i]) { count++; } else { count = 1; temp = arr[i]; } if (max_ele<count) { max_ele = count; ele = arr[i]; if (max_ele>(n/2)) { f = 1; break ; } } } return (f==1 ? ele : -1); } int main() { int arr[] = {1, 1, 2, 1, 3, 5, 1}; int n = sizeof (arr) / sizeof (arr[0]); cout<<majorityElement(arr, n); return 0; } chevron_right filter_none Output: 1

Complexity Analysis: Time Complexity : O(nlogn).

Sorting requires O(n log n) time complexity. Auxiliary Space : O(1).

As no extra space is required.







Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.