Find the majority element in the array. 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 : A[]={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 : A[] = {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.
Naive Approach:
The basic solution is to have two loops and keep track of the maximum count for all different elements. If the maximum count becomes greater than n/2 then break the loops and return the element having the maximum count. If the maximum count doesn’t become more than n/2 then the majority element doesn’t exist.
Illustration:
arr[] = {3, 4, 3, 2, 4, 4, 4, 4}, n = 8
For i = 0:
- count = 0
- Loop over the array, whenever an element is equal to arr[i] (is 3), increment count
- count of arr[i] is 2, which is less than n/2, hence it can’t be majority element.
For i = 1:
- count = 0
- Loop over the array, whenever an element is equal to arr[i] (is 4), increment count
- count of arr[i] is 5, which is greater than n/2 (i.e 4), hence it will be majority element.
Hence, 4 is the majority element.
Follow the steps below to solve the given problem:
- 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 variable.
- If the maximum count is greater than half the size of the array, print the element. Else print there is no majority element.
Below is the implementation of the above idea:
C++
#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;
}
|
C
#include <stdio.h>
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)
printf("%d\n", arr[index]);
else
printf("No Majority Element\n");
}
int main()
{
int arr[] = { 1, 1, 2, 1, 3, 5, 1 };
int n = sizeof(arr) / sizeof(arr[0]);
findMajority(arr, n);
return 0;
}
|
Java
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);
}
}
|
Python3
def findMajority(arr, n):
maxCount = 0
index = -1
for i in range(n):
count = 1
for j in range(i+1, 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)
|
C#
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);
}
}
|
Javascript
<script>
function findMajority(arr, n)
{
let maxCount = 0;
let index = -1;
for(let i = 0; i < n; i++)
{
let count = 0;
for(let j = 0; j < n; j++)
{
if (arr[i] == arr[j])
count++;
}
if (count > maxCount)
{
maxCount = count;
index = i;
}
}
if (maxCount > n / 2)
document.write(arr[index]);
else
document.write("No Majority Element");
}
let arr = [ 1, 1, 2, 1, 3, 5, 1 ];
let n = arr.length;
findMajority(arr, n);
</script>
|
PHP
<?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] . "\n";
else
echo "No Majority Element" . "\n";
}
$arr = array(1, 1, 2, 1, 3, 5, 1);
$n = sizeof($arr);
findMajority($arr, $n);
|
Time Complexity: O(n*n), A nested loop is needed where both the loops traverse the array from start to end.
Auxiliary Space: O(1), No extra space is required.
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.
Illustration:
Follow the steps below to solve the given problem:
- Create a binary search tree, if the 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 half the size of the array, then perform an inorder traversal and find the node with a frequency greater than half
- Else print No majority Element.
Below is the implementation of the above idea:
C++14
#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 \n", 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\n";
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct node {
int key;
int c;
struct node* left;
struct node* right;
};
struct node* newNode(int item) {
struct node* temp = (struct node*)malloc(sizeof(struct node));
temp->key = item;
temp->c = 1;
temp->left = NULL;
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 = (*ma > node->c) ? *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 \n", 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
printf("No majority element\n");
return 0;
}
|
Java
import java.io.*;
class Node
{
int key;
int c = 0;
Node left,right;
}
class GFG{
static int ma = 0;
static Node newNode(int item)
{
Node temp = new Node();
temp.key = item;
temp.c = 1;
temp.left = temp.right = null;
return temp;
}
static Node insert(Node node, int key)
{
if (node == null)
{
if (ma == 0)
ma = 1;
return newNode(key);
}
if (key < node.key)
node.left = insert(node.left, key);
else if (key > node.key)
node.right = insert(node.right, key);
else
node.c++;
ma = Math.max(ma, node.c);
return node;
}
static void inorder(Node root, int s)
{
if (root != null)
{
inorder(root.left, s);
if (root.c > (s / 2))
System.out.println(root.key + "\n");
inorder(root.right, s);
}
}
public static void main(String[] args)
{
int a[] = { 1, 3, 3, 3, 2 };
int size = a.length;
Node root = null;
for(int i = 0; i < size; i++)
{
root = insert(root, a[i]);
}
if (ma > (size / 2))
inorder(root, size);
else
System.out.println("No majority element\n");
}
}
|
Python3
class Node():
def __init__(self, data):
self.data = data
self.left = None
self.right = None
self.count = 1
class BST():
def __init__(self):
self.root = None
def insert(self, data, n):
out = None
if (self.root == None):
self.root = Node(data)
else:
out = self.insertNode(self.root, data, n)
return out
def insertNode(self, currentNode, data, n):
if (currentNode.data == data):
currentNode.count += 1
if (currentNode.count > n//2):
return currentNode.data
else:
return None
elif (currentNode.data < data):
if (currentNode.right):
self.insertNode(currentNode.right, data, n)
else:
currentNode.right = Node(data)
elif (currentNode.data > data):
if (currentNode.left):
self.insertNode(currentNode.left, data, n)
else:
currentNode.left = Node(data)
arr = [3, 2, 3]
n = len(arr)
tree = BST()
flag = 0
for i in range(n):
out = tree.insert(arr[i], n)
if (out != None):
print(arr[i])
flag = 1
break
if (flag == 0):
print("No Majority Element")
|
C#
using System;
public class Node
{
public int key;
public int c = 0;
public Node left,right;
}
class GFG{
static int ma = 0;
static Node newNode(int item)
{
Node temp = new Node();
temp.key = item;
temp.c = 1;
temp.left = temp.right = null;
return temp;
}
static Node insert(Node node, int key)
{
if (node == null)
{
if (ma == 0)
ma = 1;
return newNode(key);
}
if (key < node.key)
node.left = insert(node.left, key);
else if (key > node.key)
node.right = insert(node.right, key);
else
node.c++;
ma = Math.Max(ma, node.c);
return node;
}
static void inorder(Node root, int s)
{
if (root != null)
{
inorder(root.left, s);
if (root.c > (s / 2))
Console.WriteLine(root.key + "\n");
inorder(root.right, s);
}
}
static public void Main()
{
int[] a = { 1, 3, 3, 3, 2 };
int size = a.Length;
Node root = null;
for(int i = 0; i < size; i++)
{
root = insert(root, a[i]);
}
if (ma > (size / 2))
inorder(root, size);
else
Console.WriteLine("No majority element\n");
}
}
|
Javascript
<script>
class Node {
constructor(){
this.key = 0;
this.c = 0;
this.left = null,
this.right = null;
}
}
var ma = 0;
function newNode(item)
{
var temp = new Node();
temp.key = item;
temp.c = 1;
temp.left = temp.right = null;
return temp;
}
function insert(node , key) {
if (node == null) {
if (ma == 0)
ma = 1;
return newNode(key);
}
if (key < node.key)
node.left = insert(node.left, key);
else if (key > node.key)
node.right = insert(node.right, key);
else
node.c++;
ma = Math.max(ma, node.c);
return node;
}
function inorder(root , s) {
if (root != null) {
inorder(root.left, s);
if (root.c > (s / 2))
document.write(root.key + "\n");
inorder(root.right, s);
}
}
var a = [ 1, 3, 3, 3, 2 ];
var size = a.length;
var root = null;
for (i = 0; i < size; i++) {
root = insert(root, a[i]);
}
if (ma > (size / 2))
inorder(root, size);
else
document.write("No majority element\n");
</script>
|
Time Complexity: If a Binary Search Tree is used then time complexity will be O(n²). 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 the tree.
This is a two-step process:
- The first step gives the element that may be 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 the majority element. This step is necessary as there might be no majority element.
Illustration:
arr[] = {3, 4, 3, 2, 4, 4, 4, 4}, n = 8
maj_index = 0, count = 1
At i = 1: arr[maj_index] != arr[i]
- count = count – 1 = 1 – 1 = 0
- now count == 0 then:
- maj_index = i = 1
- count = count + 1 = 0 + 1 = 1
At i = 2: arr[maj_index] != arr[i]
- count = count – 1 = 1 – 1 = 0
- now count == 0 then:
- maj_index = i = 2
- count = count + 1 = 0 + 1 = 1
At i = 3: arr[maj_index] != arr[i]
- count = count – 1 = 1 – 1 = 0
- now count == 0 then:
- maj_index = i = 3
- count = count + 1 = 0 + 1 = 1
At i = 4: arr[maj_index] != arr[i]
- count = count – 1 = 1 – 1 = 0
- now count == 0 then:
- maj_index = i = 4
- count = count + 1 = 0 + 1 = 1
At i = 5: arr[maj_index] == arr[i]
- count = count + 1 = 1 + 1 = 2
At i = 6: arr[maj_index] == arr[i]
- count = count + 1 = 2 + 1 = 3
At i = 7: arr[maj_index] == arr[i]
- count = count + 1 = 3 + 1 = 4
Therefore, the arr[maj_index] may be the possible candidate for majority element.
Now, Again traverse the array and check whether arr[maj_index] is the majority element or not.
arr[maj_index] is 4
4 occurs 5 times in the array therefore 4 is our majority element.
Follow the steps below to solve the given problem:
- Loop through each element and maintains a count of the majority element, and a majority index, maj_index
- If the next element is the same then increment the count if the next element is not the same then decrement the count.
- if the count reaches 0 then change 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 the 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
Below is the implementation of the above idea:
C++
#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;
}
|
C
#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;
}
|
Java
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);
}
}
|
Python3
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)
|
C#
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);
}
}
|
Javascript
<script>
function printMajority(a, size)
{
let cand = findCandidate(a, size);
if (isMajority(a, size, cand))
document.write(" " + cand + " ");
else
document.write("No Majority Element");
}
function findCandidate(a, size)
{
let maj_index = 0, count = 1;
let 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];
}
function isMajority(a, size, cand)
{
let i, count = 0;
for (i = 0; i < size; i++) {
if (a[i] == cand)
count++;
}
if (count > parseInt(size / 2, 10))
return true;
else
return false;
}
let a = [ 1, 3, 3, 1, 2 ];
let size = a.length;
printMajority(a, size);
</script>
|
PHP
<?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);
?>
|
Output
No Majority Element
Time Complexity: 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.
Majority Element Using Hashing:
In Hashtable(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).
Illustration:
arr[] = {3, 4, 3, 2, 4, 4, 4, 4}, n = 8
Create a hashtable for the array
3 -> 2
4 -> 5
2 -> 1
Now traverse the hashtable
- Count for 3 is 2, which is less than n/2 (4) therefore it can’t be the majority element.
- Count for 4 is 5, which is greater than n/2 (4) therefore 4 is the majority element.
Hence, 4 is the majority element.
Follow the steps below to solve the given problem:
- 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 a 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”
Below is the implementation of the above idea:
C++
#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;
}
|
C
#include <stdio.h>
#include <stdlib.h>
void findMajority(int arr[], int size)
{
int i, j;
int count = 0;
for(i = 0; i < size; i++)
{
int current = arr[i];
int freq = 0;
for(j = 0; j < size; j++)
{
if(arr[j] == current)
{
freq++;
}
}
if(freq > size / 2)
{
count = 1;
printf("Majority found :- %d\n", current);
break;
}
}
if(count == 0)
{
printf("No Majority element\n");
}
}
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;
}
|
Java
import java.util.HashMap;
class MajorityElement
{
private static void findMajority(int[] arr)
{
HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
int count=0;
for(int i = 0; i < arr.length; i++)
{
if (map.containsKey(arr[i]))
{
count = map.get(arr[i]) +1;
map.put(arr[i], count);
}
else
{
map.put(arr[i],1);
}
if(map.get(arr[i]) > arr.length /2)
{
System.out.println("Majority found :- " + arr[i]);
return;
}
}
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);
}
}
|
Python3
def findMajority(arr, size):
m = {}
for i in range(size):
if arr[i] in m:
m[arr[i]] += 1
else:
m[arr[i]] = 1
is_majority_present = False
for key in m:
if m[key] > size / 2:
is_majority_present = True
print("Majority found :-",key)
break
if not is_majority_present:
print("No Majority element")
arr = [2, 2, 2, 2, 5, 5, 2, 3, 3]
n = len(arr)
findMajority(arr, n)
|
C#
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);
}
}
|
Javascript
<script>
function findMajority(arr)
{
let map = new Map();
for(let i = 0; i < arr.length; i++) {
if (map.has(arr[i])) {
let count = map.get(arr[i]) +1;
if (count > arr.length /2) {
document.write("Majority found :- " + arr[i]);
return;
} else
map.set(arr[i], count);
}
else
map.set(arr[i],1);
}
document.write(" No Majority element");
}
let a = [ 2,2,2,2,5,5,2,3,3 ];
findMajority(a);
</script>
|
Output
Majority found :- 2
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.
Majority Element Using Sorting:
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.
Illustration:
arr[] = {3, 4, 3, 2, 4, 4, 4, 4}, n = 8
Array after sorting => arr[] = {2, 3, 3, 4, 4, 4, 4, 4}, count = 1
At i = 1:
- arr[i] != arr[i – 1] => arr[1] != arr[0]
- count is not greater than n/2, therefore reinitialise count with, count = 1
At i = 2:
- arr[i] == arr[i – 1] => arr[2] == arr[1] = 3
- count = count + 1 = 1 + 1 = 2
At i = 3
- arr[i] != arr[i – 1] => arr[3] != arr[2]
- count is not greater than n/2, therefore reinitialise count with, count = 1
At i = 4
- arr[i] == arr[i – 1] => arr[4] == arr[3] = 4
- count = count + 1 = 1 + 1 = 2
At i = 5
- arr[i] == arr[i – 1] => arr[5] == arr[4] = 4
- count = count + 1 = 2 + 1 = 3
At i = 6
- arr[i] == arr[i – 1] => arr[6] == arr[5] = 4
- count = count + 1 = 3 + 1 = 4
At i = 7
- arr[i] == arr[i – 1] => arr[7] == arr[6] = 4
- count = count + 1 = 4 + 1 = 5
- Therefore, the count of 4 is now greater than n/2.
Hence, 4 is the majority element.
Follow the steps below to solve the given problem:
- Sort the array and create a variable 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 the array, print the element as the majority element and break.
- If no majority element is found, print “No majority element”
Below is the implementation of the above idea:
C++
#include <bits/stdc++.h>
using namespace std;
int majorityElement(int *arr, int n)
{
if (n == 1) return arr[0];
int cnt = 1;
sort(arr, arr + n);
for (int i = 1; i <= n; i++){
if (arr[i - 1] == arr[i]){
cnt++;
}
else{
if (cnt > n / 2){
return arr[i - 1];
}
cnt = 1;
}
}
return -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;
}
|
Java
import java.io.*;
import java.util.*;
class GFG{
public static int majorityElement(int[] arr, int n)
{
Arrays.sort(arr);
int count = 1, max_ele = -1,
temp = arr[0], ele = 0,
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);
}
public static void main(String[] args)
{
int arr[] = { 1, 1, 2, 1, 3, 5, 1 };
int n = 7;
System.out.println(majorityElement(arr, n));
}
}
|
Python3
def majorityElement(arr, n) :
arr.sort()
count, max_ele, temp, f = 1, -1, arr[0], 0
for i in range(1, n) :
if(temp == arr[i]) :
count += 1
else :
count = 1
temp = arr[i]
if(max_ele < count) :
max_ele = count
ele = arr[i]
if(max_ele > (n//2)) :
f = 1
break
if f == 1 :
return ele
else :
return -1
arr = [1, 1, 2, 1, 3, 5, 1]
n = len(arr)
print(majorityElement(arr, n))
|
C#
using System;
class GFG
{
public static int majorityElement(int[] arr, int n)
{
Array.Sort(arr);
int count = 1, max_ele = -1,
temp = arr[0], ele = 0,
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);
}
public static void Main(String[] args)
{
int []arr = { 1, 1, 2, 1, 3, 5, 1 };
int n = 7;
Console.WriteLine(majorityElement(arr, n));
}
}
|
Javascript
<script>
function majorityElement(arr, n)
{
arr.sort(function(a, b){return a - b});
let count = 1, max_ele = -1,
temp = arr[0], ele = 0,
f = 0;
for(let 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 > parseInt(n / 2, 10))
{
f = 1;
break;
}
}
}
return (f == 1 ? ele : -1);
}
let arr = [ 1, 1, 2, 1, 3, 5, 1 ];
let n = 7;
document.write(majorityElement(arr, n));
</script>
|
Time Complexity: O(nlogn), Sorting requires O(n log n) time complexity.
Auxiliary Space: O(1), As no extra space is required.
Approach using Recursion: The idea is to use the divide and conquer strategy to identify the majority element in an array using a recursive approach.
- Define a function “countOccurrences” which takes an array “arr”, its size “n”, and an integer “num” as input parameters. This function counts the number of occurrences of the given integer in the array and returns the count. And the initial count is 0.
- Then we’ll define a recursive function “findMajorityUtil” that takes an array, its lower “low” and upper “high” indices as input parameters. This function has the following steps:
- Check if the array has only one element (base case). If yes, return that element.
- Divide the array into two equal parts, left and right by finding the mid index.
- Recursively find the majority element in the left part and right part.
- If both the left and right parts have the same majority elements, then return that element.
- Count the total number of occurrences of the left and right majority elements in the entire array.
- Return the element that occurs more than n/2 times.
- Define a function “findMajority” which takes an array “arr” and its size “n” as input parameters. This function calls the “findMajorityUtil” function with the array and its indices and prints the majority element if it exists; otherwise, it will print “No Majority Element”.
- The “main” function will initialize an array “arr” and size “n”. It will call the “findMajority” function with these parameters.
C++
#include <bits/stdc++.h>
using namespace std;
int countOccurrences(int arr[], int n, int num) {
int count = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == num)
count++;
}
return count;
}
int findMajorityUtil(int arr[], int low, int high) {
if (low == high)
return arr[low];
int mid = (low + high) / 2;
int leftMajority = findMajorityUtil(arr, low, mid);
int rightMajority = findMajorityUtil(arr, mid+1, high);
if (leftMajority == rightMajority)
return leftMajority;
int leftCount = countOccurrences(arr, high-low+1, leftMajority);
int rightCount = countOccurrences(arr, high-low+1, rightMajority);
if (leftCount > (high-low+1) / 2)
return leftMajority;
if (rightCount > (high-low+1) / 2)
return rightMajority;
return -1;
}
void findMajority(int arr[], int n) {
int majority = findMajorityUtil(arr, 0, n-1);
if (majority != -1)
cout << majority << endl;
else
cout << "No Majority Element" << endl;
}
int main() {
int arr[] = {1, 3, 3, 3, 2};
int n = sizeof(arr) / sizeof(arr[0]);
findMajority(arr, n);
return 0;
}
|
C
#include <stdio.h>
int countOccurrences(int arr[], int n, int num) {
int count = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == num)
count++;
}
return count;
}
int findMajorityUtil(int arr[], int low, int high) {
if (low == high)
return arr[low];
int mid = (low + high) / 2;
int leftMajority = findMajorityUtil(arr, low, mid);
int rightMajority = findMajorityUtil(arr, mid+1, high);
if (leftMajority == rightMajority)
return leftMajority;
int leftCount = countOccurrences(arr, high-low+1, leftMajority);
int rightCount = countOccurrences(arr, high-low+1, rightMajority);
if (leftCount > (high-low+1) / 2)
return leftMajority;
if (rightCount > (high-low+1) / 2)
return rightMajority;
return -1;
}
void findMajority(int arr[], int n) {
int majority = findMajorityUtil(arr, 0, n-1);
if (majority != -1)
printf("%d\n", majority);
else
printf("No Majority Element\n");
}
int main() {
int arr[] = {1, 3, 3, 3, 2};
int n = sizeof(arr) / sizeof(arr[0]);
findMajority(arr, n);
return 0;
}
|
Java
import java.util.*;
public class MajorityElement {
public static int countOccurrences(int[] arr, int n, int num) {
int count = 0;
for (int i = 0; i < n; i++) {
if (arr[i] == num)
count++;
}
return count;
}
public static int findMajorityUtil(int[] arr, int low, int high) {
if (low == high)
return arr[low];
int mid = (low + high) / 2;
int leftMajority = findMajorityUtil(arr, low, mid);
int rightMajority = findMajorityUtil(arr, mid + 1, high);
if (leftMajority == rightMajority)
return leftMajority;
int leftCount = countOccurrences(arr, high - low + 1, leftMajority);
int rightCount = countOccurrences(arr, high - low + 1, rightMajority);
if (leftCount > (high - low + 1) / 2)
return leftMajority;
if (rightCount > (high - low + 1) / 2)
return rightMajority;
return -1;
}
public static void findMajority(int[] arr, int n) {
int majority = findMajorityUtil(arr, 0, n - 1);
if (majority != -1)
System.out.println(majority);
else
System.out.println("No Majority Element");
}
public static void main(String[] args) {
int[] arr = {1, 3, 3, 3, 2};
int n = arr.length;
findMajority(arr, n);
}
}
|
Python3
def count_occurrences(arr, num):
count = 0
for i in arr:
if i == num:
count += 1
return count
def find_majority_util(arr, low, high):
if low == high:
return arr[low]
mid = (low + high) // 2
left_majority = find_majority_util(arr, low, mid)
right_majority = find_majority_util(arr, mid+1, high)
if left_majority == right_majority:
return left_majority
left_count = count_occurrences(arr[low:high+1], left_majority)
right_count = count_occurrences(arr[low:high+1], right_majority)
if left_count > (high-low+1) // 2:
return left_majority
if right_count > (high-low+1) // 2:
return right_majority
return -1
def find_majority(arr):
n = len(arr)
majority = find_majority_util(arr, 0, n-1)
if majority != -1:
print(majority)
else:
print("No Majority Element")
if __name__ == "__main__":
arr = [1, 3, 3, 3, 2]
n = len(arr)
find_majority(arr)
|
C#
using System;
class Program
{
static int CountOccurrences(int[] arr, int num)
{
int count = 0;
foreach (int element in arr)
{
if (element == num)
count++;
}
return count;
}
static int FindMajorityUtil(int[] arr, int low, int high)
{
if (low == high)
return arr[low];
int mid = (low + high) / 2;
int leftMajority = FindMajorityUtil(arr, low, mid);
int rightMajority = FindMajorityUtil(arr, mid + 1, high);
if (leftMajority == rightMajority)
return leftMajority;
int leftCount = CountOccurrences(arr, leftMajority);
int rightCount = CountOccurrences(arr, rightMajority);
if (leftCount > (high - low + 1) / 2)
return leftMajority;
if (rightCount > (high - low + 1) / 2)
return rightMajority;
return -1;
}
static void FindMajority(int[] arr)
{
int n = arr.Length;
int majority = FindMajorityUtil(arr, 0, n - 1);
if (majority != -1)
Console.WriteLine(majority);
else
Console.WriteLine("No Majority Element");
}
static void Main(string[] args)
{
int[] arr = { 1, 3, 3, 3, 2 };
FindMajority(arr);
}
}
|
Javascript
function countOccurrences(arr, n, num) {
let count = 0;
for (let i = 0; i < n; i++) {
if (arr[i] == num)
count++;
}
return count;
}
function findMajorityUtil( arr, low, high) {
if (low == high)
return arr[low];
let mid = Math.floor((low + high) / 2);
let leftMajority = findMajorityUtil(arr, low, mid);
let rightMajority = findMajorityUtil(arr, mid+1, high);
if (leftMajority == rightMajority)
return leftMajority;
let leftCount = countOccurrences(arr, high-low+1, leftMajority);
let rightCount = countOccurrences(arr, high-low+1, rightMajority);
if (leftCount > Math.floor((high-low+1) / 2))
return leftMajority;
if (rightCount > Math.floor((high-low+1) / 2))
return rightMajority;
return -1;
}
function findMajority(arr, n) {
let majority = findMajorityUtil(arr, 0, n-1);
if (majority != -1)
document.write(majority);
else
document.write("No Majority Element");
}
let arr = [1, 3, 3, 3, 2];
let n = arr.length;
findMajority(arr, n);
|
Time Complexity: O(N*log N)
Space Complexity: O(log N)
Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!
Last Updated :
02 Dec, 2023
Like Article
Save Article