# Majority Element

Last Updated : 02 Dec, 2023

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.

Recommended Practice

## 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++

 `// C++ program to find Majority` `// element in an array` `#include ` `using` `namespace` `std;`   `// Function to find Majority element` `// in an array` `void` `findMajority(``int` `arr[], ``int` `n)` `{` `    ``int` `maxCount = 0;` `    ``int` `index = -1; ``// sentinels` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `count = 0;` `        ``for` `(``int` `j = 0; j < n; j++) {` `            ``if` `(arr[i] == arr[j])` `                ``count++;` `        ``}`   `        ``// update maxCount if count of` `        ``// current element is greater` `        ``if` `(count > maxCount) {` `            ``maxCount = count;` `            ``index = i;` `        ``}` `    ``}`   `    ``// if maxCount is greater than n/2` `    ``// return the corresponding element` `    ``if` `(maxCount > n / 2)` `        ``cout << arr[index] << endl;`   `    ``else` `        ``cout << ``"No Majority Element"` `<< endl;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 1, 3, 5, 1 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``// Function calling` `    ``findMajority(arr, n);`   `    ``return` `0;` `}`

## C

 `#include ` `  `  `// Function to find Majority element` `// in an array` `void` `findMajority(``int` `arr[], ``int` `n)` `{` `    ``int` `maxCount = 0;` `    ``int` `index = -1; ``// sentinels` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `count = 0;` `        ``for` `(``int` `j = 0; j < n; j++) {` `            ``if` `(arr[i] == arr[j])` `                ``count++;` `        ``}` `  `  `        ``// update maxCount if count of` `        ``// current element is greater` `        ``if` `(count > maxCount) {` `            ``maxCount = count;` `            ``index = i;` `        ``}` `    ``}` `  `  `    ``// if maxCount is greater than n/2` `    ``// return the corresponding element` `    ``if` `(maxCount > n / 2)` `        ``printf``(``"%d\n"``, arr[index]);` `  `  `    ``else` `        ``printf``(``"No Majority Element\n"``);` `}` `  `  `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 1, 3, 5, 1 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `  `  `    ``// Function calling` `    ``findMajority(arr, n);` `  `  `    ``return` `0;` `}`   `// This code is contributed by Vaibhav Saroj.`

## Java

 `// Java program to find Majority` `// element in an array`   `import` `java.io.*;`   `class` `GFG {`   `    ``// Function to find Majority element` `    ``// in an array` `    ``static` `void` `findMajority(``int` `arr[], ``int` `n)` `    ``{` `        ``int` `maxCount = ``0``;` `        ``int` `index = -``1``; ``// sentinels` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``int` `count = ``0``;` `            ``for` `(``int` `j = ``0``; j < n; j++) {` `                ``if` `(arr[i] == arr[j])` `                    ``count++;` `            ``}`   `            ``// update maxCount if count of` `            ``// current element is greater` `            ``if` `(count > maxCount) {` `                ``maxCount = count;` `                ``index = i;` `            ``}` `        ``}`   `        ``// if maxCount is greater than n/2` `        ``// return the corresponding element` `        ``if` `(maxCount > n / ``2``)` `            ``System.out.println(arr[index]);`   `        ``else` `            ``System.out.println(``"No Majority Element"``);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``int` `arr[] = { ``1``, ``1``, ``2``, ``1``, ``3``, ``5``, ``1` `};` `        ``int` `n = arr.length;`   `        ``// Function calling` `        ``findMajority(arr, n);` `    ``}` `    ``// This code is contributed by ajit.` `}`

## Python3

 `# Python3 program to find Majority` `# element in an array`   `# Function to find Majority` `# element in an array`     `def` `findMajority(arr, n):`   `    ``maxCount ``=` `0` `    ``index ``=` `-``1`  `# sentinels` `    ``for` `i ``in` `range``(n):`   `        ``count ``=` `1` `        ``# here we compare the element in ` `        ``# ith position with i+1th position` `        ``for` `j ``in` `range``(i``+``1``, n):`   `            ``if``(arr[i] ``=``=` `arr[j]):` `                ``count ``+``=` `1`   `        ``# update maxCount if count of` `        ``# current element is greater` `        ``if``(count > maxCount):`   `            ``maxCount ``=` `count` `            ``index ``=` `i`   `    ``# if maxCount is greater than n/2` `    ``# return the corresponding element` `    ``if` `(maxCount > n``/``/``2``):` `        ``print``(arr[index])`   `    ``else``:` `        ``print``(``"No Majority Element"``)`     `# Driver code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1``, ``1``, ``2``, ``1``, ``3``, ``5``, ``1``]` `    ``n ``=` `len``(arr)`   `    ``# Function calling` `    ``findMajority(arr, n)`   `# This code is contributed` `# by ChitraNayal`

## C#

 `// C# program to find Majority` `// element in an array` `using` `System;`   `public` `class` `GFG {`   `    ``// Function to find Majority element` `    ``// in an array` `    ``static` `void` `findMajority(``int``[] arr, ``int` `n)` `    ``{` `        ``int` `maxCount = 0;` `        ``int` `index = -1; ``// sentinels` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``int` `count = 0;` `            ``for` `(``int` `j = 0; j < n; j++) {` `                ``if` `(arr[i] == arr[j])` `                    ``count++;` `            ``}`   `            ``// update maxCount if count of` `            ``// current element is greater` `            ``if` `(count > maxCount) {` `                ``maxCount = count;` `                ``index = i;` `            ``}` `        ``}`   `        ``// if maxCount is greater than n/2` `        ``// return the corresponding element` `        ``if` `(maxCount > n / 2)` `            ``Console.WriteLine(arr[index]);`   `        ``else` `            ``Console.WriteLine(``"No Majority Element"``);` `    ``}`   `    ``// Driver code` `    ``static` `public` `void` `Main()` `    ``{`   `        ``int``[] arr = { 1, 1, 2, 1, 3, 5, 1 };` `        ``int` `n = arr.Length;`   `        ``// Function calling` `        ``findMajority(arr, n);` `    ``}` `    ``// This code is contributed by Tushil..` `}`

## Javascript

 ``

## PHP

 ` ``\$maxCount``)` `        ``{` `            ``\$maxCount` `= ``\$count``;` `            ``\$index` `= ``\$i``;` `        ``}` `    ``}` `    `  `    ``// if maxCount is greater than n/2 ` `    ``// return the corresponding element ` `    ``if` `(``\$maxCount` `> ``\$n``/2)` `        ``echo` `\$arr``[``\$index``] . ``"\n"``;` `    ``else` `        ``echo` `"No Majority Element"` `. ``"\n"``;` `}`   `// Driver code` `\$arr` `= ``array``(1, 1, 2, 1, 3, 5, 1);` `\$n` `= sizeof(``\$arr``);` `    `  `// Function calling ` `findMajority(``\$arr``, ``\$n``);`   `// This code is contributed ` `// by Akanksha Rai`

Output

```1

```

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.

## Majority Element using Binary Search Tree

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

 `// C++ program to demonstrate insert operation in binary` `// search tree.` `#include ` `using` `namespace` `std;`   `struct` `node {` `    ``int` `key;` `    ``int` `c = 0;` `    ``struct` `node *left, *right;` `};`   `// A utility function to create a new BST node` `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;` `}`   `// A utility function to insert a new node with given key in` `// BST` `struct` `node* insert(``struct` `node* node, ``int` `key, ``int``& ma)` `{` `    ``// If the tree is empty, return a new node` `    ``if` `(node == NULL) {` `        ``if` `(ma == 0)` `            ``ma = 1;`   `        ``return` `newNode(key);` `    ``}`   `    ``// Otherwise, recur down the tree` `    ``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++;`   `    ``// find the max count` `    ``ma = max(ma, node->c);`   `    ``// return the (unchanged) node pointer` `    ``return` `node;` `}`   `// A utility function to do inorder traversal of BST` `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);` `    ``}` `}` `// Driver Code` `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);` `    ``}`   `    ``// Function call` `    ``if` `(ma > (size / 2))` `        ``inorder(root, size);` `    ``else` `        ``cout << ``"No majority element\n"``;` `    ``return` `0;` `}`

## C

 `#include ` `#include `   `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;` `}`   `// This code is contributed by Vaibhav Saroj.`

## Java

 `// Java program to demonstrate insert ` `// operation in binary search tree.` `import` `java.io.*;`   `class` `Node` `{` `    ``int` `key;` `    ``int` `c = ``0``;` `    ``Node left,right;` `    `  `}` `class` `GFG{` `    `  `static` `int` `ma = ``0``;`   `// A utility function to create a ` `// new BST node` `static` `Node newNode(``int` `item)` `{` `    ``Node temp = ``new` `Node();` `    ``temp.key = item;` `    ``temp.c = ``1``;` `    ``temp.left = temp.right = ``null``;` `    ``return` `temp;` `}`   `// A utility function to insert a new node` `// with given key in BST` `static` `Node insert(Node node, ``int` `key)` `{` `    `  `    ``// If the tree is empty, ` `    ``// return a new node` `    ``if` `(node == ``null``) ` `    ``{` `        ``if` `(ma == ``0``)` `            ``ma = ``1``;`   `        ``return` `newNode(key);` `    ``}` `    `  `    ``// Otherwise, recur down the tree` `    ``if` `(key < node.key)` `        ``node.left = insert(node.left, key);` `    ``else` `if` `(key > node.key)` `        ``node.right = insert(node.right, key);` `    ``else` `        ``node.c++;`   `    ``// Find the max count` `    ``ma = Math.max(ma, node.c);` ` `  `    ``// Return the (unchanged) node pointer` `    ``return` `node;` `}`   `// A utility function to do inorder` `// traversal of BST` `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);` `    ``}` `}`   `// Driver Code` `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]);` `    ``}` `    `  `    ``// Function call` `    ``if` `(ma > (size / ``2``))` `        ``inorder(root, size);` `    ``else` `        ``System.out.println(``"No majority element\n"``);` `}` `}`   `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python3 program to demonstrate insert operation in binary` `# search tree.` `# class for creating node` `class` `Node():` `    ``def` `__init__(``self``, data):` `        ``self``.data ``=` `data` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` `        ``self``.count ``=` `1`  `# count of number of times data is inserted in tree`   `# class for binary search tree` `# it initialises tree with None root` `# insert function inserts node as per BST rule` `# and also checks for majority element` `# if no majority element is found yet, it returns None`     `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)`     `# Driver code` `# declaring an array` `arr ``=` `[``3``, ``2``, ``3``]` `n ``=` `len``(arr)`   `# declaring None tree` `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#

 `// C# program to demonstrate insert ` `// operation in binary search tree.` `using` `System;`   `public` `class` `Node` `{` `    ``public` `int` `key;` `    ``public` `int` `c = 0;` `    ``public` `Node left,right;` `     `  `}`   `class` `GFG{` `    `  `static` `int` `ma = 0;`   `// A utility function to create a ` `// new BST node` `static` `Node newNode(``int` `item)` `{` `    ``Node temp = ``new` `Node();` `    ``temp.key = item;` `    ``temp.c = 1;` `    ``temp.left = temp.right = ``null``;` `    ``return` `temp;` `}` ` `  `// A utility function to insert a new node` `// with given key in BST` `static` `Node insert(Node node, ``int` `key)` `{` `    `  `    ``// If the tree is empty, ` `    ``// return a new node` `    ``if` `(node == ``null``) ` `    ``{` `        ``if` `(ma == 0)` `            ``ma = 1;` ` `  `        ``return` `newNode(key);` `    ``}` `     `  `    ``// Otherwise, recur down the tree` `    ``if` `(key < node.key)` `        ``node.left = insert(node.left, key);` `    ``else` `if` `(key > node.key)` `        ``node.right = insert(node.right, key);` `    ``else` `        ``node.c++;` ` `  `    ``// Find the max count` `    ``ma = Math.Max(ma, node.c);` `  `  `    ``// Return the (unchanged) node pointer` `    ``return` `node;` `}` ` `  `// A utility function to do inorder` `// traversal of BST` `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);` `    ``}` `}`   `// Driver Code` `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]);` `    ``}` `    `  `    ``// Function call` `    ``if` `(ma > (size / 2))` `        ``inorder(root, size);` `    ``else` `        ``Console.WriteLine(``"No majority element\n"``);` `}` `}`   `// This code is contributed by rag2127`

## Javascript

 ``

Output

```3

```

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.

## Majority Element Using Mooreâ€™s Voting Algorithm:

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++

 `// C++ Program for finding out` `// majority element in an array ` `#include ` `using` `namespace` `std;`   `/* Function to find the candidate for Majority */` `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];` `}`   `/* Function to check if the candidate` `   ``occurs more than n/2 times */` `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;` `}`   `/* Function to print Majority Element */` `void` `printMajority(``int` `a[], ``int` `size)` `{` `    ``/* Find the candidate for Majority*/` `    ``int` `cand = findCandidate(a, size);`   `    ``/* Print the candidate if it is Majority*/` `    ``if` `(isMajority(a, size, cand))` `        ``cout << ``" "` `<< cand << ``" "``;`   `    ``else` `        ``cout << ``"No Majority Element"``;` `}`   `/* Driver code */` `int` `main()` `{` `    ``int` `a[] = { 1, 3, 3, 1, 2 };` `    ``int` `size = (``sizeof``(a)) / ``sizeof``(a[0]);`   `    ``// Function calling` `    ``printMajority(a, size);`   `    ``return` `0;` `}`

## C

 `/* Program for finding out majority element in an array */` `#include ` `#define bool int`   `int` `findCandidate(``int``*, ``int``);` `bool` `isMajority(``int``*, ``int``, ``int``);`   `/* Function to print Majority Element */` `void` `printMajority(``int` `a[], ``int` `size)` `{` `    ``/* Find the candidate for Majority*/` `    ``int` `cand = findCandidate(a, size);`   `    ``/* Print the candidate if it is Majority*/` `    ``if` `(isMajority(a, size, cand))` `        ``printf``(``" %d "``, cand);` `    ``else` `        ``printf``(``"No Majority Element"``);` `}`   `/* Function to find the candidate for Majority */` `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];` `}`   `/* Function to check if the candidate occurs more than n/2` ` ``* times */` `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;` `}`   `/* Driver code */` `int` `main()` `{` `    ``int` `a[] = { 1, 3, 3, 1, 2 };` `    ``int` `size = (``sizeof``(a)) / ``sizeof``(a[0]);` `  `  `    ``// Function call` `    ``printMajority(a, size);` `    ``getchar``();` `    ``return` `0;` `}`

## Java

 `/* Program for finding out majority element in an array */`   `class` `MajorityElement {` `    ``/* Function to print Majority Element */` `    ``void` `printMajority(``int` `a[], ``int` `size)` `    ``{` `        ``/* Find the candidate for Majority*/` `        ``int` `cand = findCandidate(a, size);`   `        ``/* Print the candidate if it is Majority*/` `        ``if` `(isMajority(a, size, cand))` `            ``System.out.println(``" "` `+ cand + ``" "``);` `        ``else` `            ``System.out.println(``"No Majority Element"``);` `    ``}`   `    ``/* Function to find the candidate for Majority */` `    ``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];` `    ``}`   `    ``/* Function to check if the candidate occurs more` `       ``than n/2 times */` `    ``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``;` `    ``}`   `    ``/* Driver code */` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``MajorityElement majorelement` `            ``= ``new` `MajorityElement();` `        ``int` `a[] = ``new` `int``[] { ``1``, ``3``, ``3``, ``1``, ``2` `};` `      `  `        ``// Function call` `        ``int` `size = a.length;` `        ``majorelement.printMajority(a, size);` `    ``}` `}`   `// This code has been contributed by Mayank Jaiswal`

## Python3

 `# Program for finding out majority element in an array`   `# Function to find the candidate for Majority`     `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]`   `# Function to check if the candidate occurs more than n/2 times`     `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`   `# Function to print Majority Element`     `def` `printMajority(A):` `    ``# Find the candidate for Majority` `    ``cand ``=` `findCandidate(A)`   `    ``# Print the candidate if it is Majority` `    ``if` `isMajority(A, cand) ``=``=` `True``:` `        ``print``(cand)` `    ``else``:` `        ``print``(``"No Majority Element"``)`     `# Driver code` `A ``=` `[``1``, ``3``, ``3``, ``1``, ``2``]`   `# Function call` `printMajority(A)`

## C#

 `// C# Program for finding out majority element in an array` `using` `System;`   `class` `GFG {` `    ``/* Function to print Majority Element */` `    ``static` `void` `printMajority(``int``[] a, ``int` `size)` `    ``{` `        ``/* Find the candidate for Majority*/` `        ``int` `cand = findCandidate(a, size);`   `        ``/* Print the candidate if it is Majority*/` `        ``if` `(isMajority(a, size, cand))` `            ``Console.Write(``" "` `+ cand + ``" "``);` `        ``else` `            ``Console.Write(``"No Majority Element"``);` `    ``}`   `    ``/* Function to find the candidate for Majority */` `    ``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];` `    ``}`   `    ``// Function to check if the candidate` `    ``// occurs more than n/2 times` `    ``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``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main()` `    ``{`   `        ``int``[] a = { 1, 3, 3, 1, 2 };` `        ``int` `size = a.Length;` `      `  `        ``// Function call` `        ``printMajority(a, size);` `    ``}` `}`   `// This code is contributed by Sam007`

## Javascript

 ``

## PHP

 ` ``\$size` `/ 2)` `    ``return` `1;` `    `  `    ``else` `    ``return` `0;` `}`   `// Function to print Majority Element ` `function` `printMajority(``\$a``, ``\$size``)` `{` `    ``/* Find the candidate for Majority*/` `    ``\$cand` `= findCandidate(``\$a``, ``\$size``);` `    `  `    ``/* Print the candidate if it is Majority*/` `    ``if` `(isMajority(``\$a``, ``\$size``, ``\$cand``))` `        ``echo` `" "``, ``\$cand``, ``" "``;` `    ``else` `        ``echo` `"No Majority Element"``;` `}`   `// Driver Code` `\$a` `= ``array``(1, 3, 3, 1, 2);` `\$size` `= sizeof(``\$a``);`   `// Function calling` `printMajority(``\$a``, ``\$size``);`   `// This code is contributed by jit_t` `?>`

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++

 `/* C++ program for finding out majority ` `element in an array */` `#include ` `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<

## C

 `#include ` `#include `   `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"``);` `    ``}` `}`   `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = {2, 2, 2, 2, 5, 5, 2, 3, 3}; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `      `  `    ``// Function calling ` `    ``findMajority(arr, n); ` `  `  `    ``return` `0; ` `}`

## Java

 `import` `java.util.HashMap;`   `/* Program for finding out majority element in an array */` ` `  `class` `MajorityElement` `{ ` `  ``private` `static` `void` `findMajority(``int``[] arr) ` `    ``{ ` `      ``HashMap map = ``new` `HashMap(); ` `      ``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"``); ` `     ``} ` `/* Driver program to test the above functions */` `    ``public` `static` `void` `main(String[] args) ` `      ``{ ` `        ``int` `a[] = ``new` `int``[]{``2``,``2``,``2``,``2``,``5``,``5``,``2``,``3``,``3``}; ` `        ``findMajority(a); ` `      ``} ` `}` `// Improved By Karan Bajaj`   `// This code is contributed by  karan malhotra`

## Python3

 `# Python3 program for finding out majority ` `# element in an array `   `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"``)`   `# Driver code ` `arr ``=` `[``2``, ``2``, ``2``, ``2``, ``5``, ``5``, ``2``, ``3``, ``3``] ` `n ``=` `len``(arr)`   `# Function calling ` `findMajority(arr, n)`   `# This code is contributed by ankush_953`

## C#

 `// C# Program for finding out majority` `// element in an array ` `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"``);` `}`     `// Driver Code` `public` `static` `void` `Main(``string``[] args)` `{` `    ``int``[] a = ``new` `int``[]{2, 2, 2, 2, ` `                        ``5, 5, 2, 3, 3};`   `    ``findMajority(a);` `}` `}`   `// This code is contributed by Shrikant13`

## Javascript

 ``

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++

 `// C++ program to find Majority ` `// element in an array` `#include ` `using` `namespace` `std;`   `// Function to find Majority element` `// in an array` `// it returns -1 if there is no majority element`   `int` `majorityElement(``int` `*arr, ``int` `n)` `{` `    ``if` `(n == 1) ``return` `arr[0];` `    `  `    ``int` `cnt = 1;` `      ``// sort the array, o(nlogn)` `    ``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;` `        ``}` `    ``}` `    ``// if no majority element, return -1` `    ``return` `-1;` `}`     `// Driver code` `int` `main()` `{` `    ``int` `arr[] = {1, 1, 2, 1, 3, 5, 1};` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    `  `    ``// Function calling ` `    ``cout<

## Java

 `// Java program to find Majority  ` `// element in an array ` `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG{`   `// Function to find Majority element ` `// in an array it returns -1 if there` `// is no majority element   ` `public` `static` `int` `majorityElement(``int``[] arr, ``int` `n)` `{` `    `  `    ``// Sort the array in O(nlogn)` `    ``Arrays.sort(arr);`   `    ``int` `count = ``1``, max_ele = -``1``, ` `         ``temp = arr[``0``], ele = ``0``,` `            ``f = ``0``;`   `    ``for``(``int` `i = ``1``; i <= n; i++)` `    ``{` `        `  `        ``// Increases the count if the ` `        ``// same element occurs otherwise` `        ``// starts counting new element` `        ``if` `(temp == arr[i])` `        ``{` `            ``count++;` `        ``}` `        ``else` `        ``{` `            ``count = ``1``;` `            ``temp = arr[i];` `        ``}`   `        ``// Sets maximum count and stores` `        ``// maximum occurred element so far` `        ``// if maximum count becomes greater` `        ``// than n/2 it breaks out setting` `        ``// the flag` `        ``if` `(max_ele < count) ` `        ``{` `            ``max_ele = count;` `            ``ele = arr[i];`   `            ``if` `(max_ele > (n / ``2``)) ` `            ``{` `                ``f = ``1``;` `                ``break``;` `            ``}` `        ``}` `    ``}`   `    ``// Returns maximum occurred element` `    ``// if there is no such element, returns -1` `    ``return` `(f == ``1` `? ele : -``1``);` `}`   `// Driver code ` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``1``, ``1``, ``2``, ``1``, ``3``, ``5``, ``1` `};` `    ``int` `n = ``7``;`   `    ``System.out.println(majorityElement(arr, n));` `}` `}`   `// This code is contributed by RohitOberoi`

## Python3

 `# Python3 program to find Majority ` `# element in an array`   `# Function to find Majority element` `# in an array` `# it returns -1 if there is no majority element` `def` `majorityElement(arr, n) :` `    `  `    ``# sort the array in O(nlogn)` `    ``arr.sort()   ` `    ``count, max_ele, temp, f ``=` `1``, ``-``1``, arr[``0``], ``0` `    ``for` `i ``in` `range``(``1``, n) :` `        `  `        ``# increases the count if the same element occurs` `        ``# otherwise starts counting new element` `        ``if``(temp ``=``=` `arr[i]) :` `            ``count ``+``=` `1` `        ``else` `:` `            ``count ``=` `1` `            ``temp ``=` `arr[i]` `            `  `        ``# sets maximum count` `        ``# and stores maximum occurred element so far` `        ``# if maximum count becomes greater than n/2` `        ``# it breaks out setting the flag` `        ``if``(max_ele < count) :` `            ``max_ele ``=` `count` `            ``ele ``=` `arr[i]` `            `  `            ``if``(max_ele > (n``/``/``2``)) :` `                ``f ``=` `1` `                ``break` `            `  `    ``# returns maximum occurred element` `    ``# if there is no such element, returns -1` `    ``if` `f ``=``=` `1` `:` `        ``return` `ele` `    ``else` `:` `        ``return` `-``1`   `# Driver code` `arr ``=` `[``1``, ``1``, ``2``, ``1``, ``3``, ``5``, ``1``]` `n ``=` `len``(arr)`   `# Function calling ` `print``(majorityElement(arr, n))`   `# This code is contributed by divyeshrabadiya07`

## C#

 `// C# program to find Majority  ` `// element in an array ` `using` `System;` `class` `GFG` `{`   `// Function to find Majority element ` `// in an array it returns -1 if there` `// is no majority element   ` `public` `static` `int` `majorityElement(``int``[] arr, ``int` `n)` `{` `    `  `    ``// Sort the array in O(nlogn)` `    ``Array.Sort(arr);`   `    ``int` `count = 1, max_ele = -1, ` `         ``temp = arr[0], ele = 0,` `            ``f = 0;`   `    ``for``(``int` `i = 1; i < n; i++)` `    ``{` `        `  `        ``// Increases the count if the ` `        ``// same element occurs otherwise` `        ``// starts counting new element` `        ``if` `(temp == arr[i])` `        ``{` `            ``count++;` `        ``}` `        ``else` `        ``{` `            ``count = 1;` `            ``temp = arr[i];` `        ``}`   `        ``// Sets maximum count and stores` `        ``// maximum occurred element so far` `        ``// if maximum count becomes greater` `        ``// than n/2 it breaks out setting` `        ``// the flag` `        ``if` `(max_ele < count) ` `        ``{` `            ``max_ele = count;` `            ``ele = arr[i];`   `            ``if` `(max_ele > (n / 2)) ` `            ``{` `                ``f = 1;` `                ``break``;` `            ``}` `        ``}` `    ``}`   `    ``// Returns maximum occurred element` `    ``// if there is no such element, returns -1` `    ``return` `(f == 1 ? ele : -1);` `}`   `// Driver code ` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `[]arr = { 1, 1, 2, 1, 3, 5, 1 };` `    ``int` `n = 7;` `    ``Console.WriteLine(majorityElement(arr, n));` `}` `}`   `// This code is contributed by aashish1995 `

## Javascript

 ``

Output

```1

```

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++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to count the occurrences` `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;` `}`   `// Function to find the majority element` `// using recursion` `int` `findMajorityUtil(``int` `arr[], ``int` `low, ``int` `high) {` `  `  `    ``// Base case: single element array` `    ``if` `(low == high)` `        ``return` `arr[low];`   `    ``// Divide the array into left` `  ``// and right halves` `    ``int` `mid = (low + high) / 2;` `    ``int` `leftMajority = findMajorityUtil(arr, low, mid);` `    ``int` `rightMajority = findMajorityUtil(arr, mid+1, high);`   `    ``// If left and right halves have the ` `  ``// same majority element` `    ``if` `(leftMajority == rightMajority)` `        ``return` `leftMajority;`   `    ``// Count the occurrences of the` `  ``// majority element in entire array` `    ``int` `leftCount = countOccurrences(arr, high-low+1, leftMajority);` `    ``int` `rightCount = countOccurrences(arr, high-low+1, rightMajority);`   `    ``// Return the element that occurs` `  ``// more than n/2 times` `    ``if` `(leftCount > (high-low+1) / 2)` `        ``return` `leftMajority;` `    ``if` `(rightCount > (high-low+1) / 2)` `        ``return` `rightMajority;`   `    ``// No majority element` `    ``return` `-1;` `}`   `// Function to find the majority element` `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;` `}`   `// Driver Code` `int` `main() {` `    ``int` `arr[] = {1, 3, 3, 3, 2};` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);`   `    ``findMajority(arr, n);`   `    ``return` `0;` `}`

## C

 `#include `   `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) {` `    ``// Base case: single element array` `    ``if` `(low == high)` `        ``return` `arr[low];`   `    ``// Divide the array into left` `  ``// and right halves` `    ``int` `mid = (low + high) / 2;` `    ``int` `leftMajority = findMajorityUtil(arr, low, mid);` `    ``int` `rightMajority = findMajorityUtil(arr, mid+1, high);`   `    ``// If left and right halves have the` `  ``//same majority element` `    ``if` `(leftMajority == rightMajority)` `        ``return` `leftMajority;`   `    ``// Count the occurrences of the majority` `  ``// element in the entire array` `    ``int` `leftCount = countOccurrences(arr, high-low+1, leftMajority);` `    ``int` `rightCount = countOccurrences(arr, high-low+1, rightMajority);`   `    ``// Return the element that occurs` `  ``// more than n/2 times` `    ``if` `(leftCount > (high-low+1) / 2)` `        ``return` `leftMajority;` `    ``if` `(rightCount > (high-low+1) / 2)` `        ``return` `rightMajority;`   `    ``// No majority element` `    ``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 {`   `    ``// Function to count the occurrences` `    ``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;` `    ``}`   `    ``// Function to find the majority element using recursion` `    ``public` `static` `int` `findMajorityUtil(``int``[] arr, ``int` `low, ``int` `high) {`   `        ``// Base case: single element array` `        ``if` `(low == high)` `            ``return` `arr[low];`   `        ``// Divide the array into left and right halves` `        ``int` `mid = (low + high) / ``2``;` `        ``int` `leftMajority = findMajorityUtil(arr, low, mid);` `        ``int` `rightMajority = findMajorityUtil(arr, mid + ``1``, high);`   `        ``// If left and right halves have the same majority element` `        ``if` `(leftMajority == rightMajority)` `            ``return` `leftMajority;`   `        ``// Count the occurrences of the majority element in entire array` `        ``int` `leftCount = countOccurrences(arr, high - low + ``1``, leftMajority);` `        ``int` `rightCount = countOccurrences(arr, high - low + ``1``, rightMajority);`   `        ``// Return the element that occurs more than n/2 times` `        ``if` `(leftCount > (high - low + ``1``) / ``2``)` `            ``return` `leftMajority;` `        ``if` `(rightCount > (high - low + ``1``) / ``2``)` `            ``return` `rightMajority;`   `        ``// No majority element` `        ``return` `-``1``;` `    ``}`   `    ``// Function to find the majority element` `    ``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"``);` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = {``1``, ``3``, ``3``, ``3``, ``2``};` `        ``int` `n = arr.length;`   `        ``findMajority(arr, n);` `    ``}` `}` `// This code is contributed by Prajwal Kandekar`

## Python3

 `# Function to count the occurrences` `def` `count_occurrences(arr, num):` `    ``count ``=` `0` `    ``for` `i ``in` `arr:` `        ``if` `i ``=``=` `num:` `            ``count ``+``=` `1` `    ``return` `count`   `# Function to find the majority element using recursion` `def` `find_majority_util(arr, low, high):` `    ``# Base case: single element array` `    ``if` `low ``=``=` `high:` `        ``return` `arr[low]`   `    ``# Divide the array into left and right halves` `    ``mid ``=` `(low ``+` `high) ``/``/` `2` `    ``left_majority ``=` `find_majority_util(arr, low, mid)` `    ``right_majority ``=` `find_majority_util(arr, mid``+``1``, high)`   `    ``# If left and right halves have the same majority element` `    ``if` `left_majority ``=``=` `right_majority:` `        ``return` `left_majority`   `    ``# Count the occurrences of the majority element in the entire array` `    ``left_count ``=` `count_occurrences(arr[low:high``+``1``], left_majority)` `    ``right_count ``=` `count_occurrences(arr[low:high``+``1``], right_majority)`   `    ``# Return the element that occurs more than n/2 times` `    ``if` `left_count > (high``-``low``+``1``) ``/``/` `2``:` `        ``return` `left_majority` `    ``if` `right_count > (high``-``low``+``1``) ``/``/` `2``:` `        ``return` `right_majority`   `    ``# No majority element` `    ``return` `-``1`   `# Function to find the majority element` `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"``)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1``, ``3``, ``3``, ``3``, ``2``]` `    ``n ``=` `len``(arr)`   `    ``find_majority(arr)` `    `  `# This code is contributed by rambabuguphka`

## C#

 `using` `System;`   `class` `Program` `{` `    ``// Function to count the occurrences` `    ``static` `int` `CountOccurrences(``int``[] arr, ``int` `num)` `    ``{` `        ``int` `count = 0;` `        ``foreach` `(``int` `element ``in` `arr)` `        ``{` `            ``if` `(element == num)` `                ``count++;` `        ``}` `        ``return` `count;` `    ``}`   `    ``// Function to find the majority element using recursion` `    ``static` `int` `FindMajorityUtil(``int``[] arr, ``int` `low, ``int` `high)` `    ``{` `        ``// Base case: single element array` `        ``if` `(low == high)` `            ``return` `arr[low];`   `        ``// Divide the array into left and right halves` `        ``int` `mid = (low + high) / 2;` `        ``int` `leftMajority = FindMajorityUtil(arr, low, mid);` `        ``int` `rightMajority = FindMajorityUtil(arr, mid + 1, high);`   `        ``// If left and right halves have the same majority element` `        ``if` `(leftMajority == rightMajority)` `            ``return` `leftMajority;`   `        ``// Count the occurrences of the majority element in the entire array` `        ``int` `leftCount = CountOccurrences(arr, leftMajority);` `        ``int` `rightCount = CountOccurrences(arr, rightMajority);`   `        ``// Return the element that occurs more than n/2 times` `        ``if` `(leftCount > (high - low + 1) / 2)` `            ``return` `leftMajority;` `        ``if` `(rightCount > (high - low + 1) / 2)` `            ``return` `rightMajority;`   `        ``// No majority element` `        ``return` `-1;` `    ``}`   `    ``// Function to find the majority element` `    ``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"``);` `    ``}`   `    ``// Driver Code` `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``int``[] arr = { 1, 3, 3, 3, 2 };` `        ``FindMajority(arr);`   `        ``// Output will be either the majority element or "No Majority Element"` `    ``}` `}`

## Javascript

 `// JS program for the above approach`   `// Function to count the occurrences` `function` `countOccurrences(arr, n, num) {` `    ``let count = 0;` `    ``for` `(let i = 0; i < n; i++) {` `        ``if` `(arr[i] == num)` `            ``count++;` `    ``}` `    ``return` `count;` `}`   `// Function to find the majority element` `// using recursion` `function` `findMajorityUtil( arr,  low,  high) {` `  `  `    ``// Base case: single element array` `    ``if` `(low == high)` `        ``return` `arr[low];`   `    ``// Divide the array into left` `  ``// and right halves` `    ``let mid = Math.floor((low + high) / 2);` `    ``let leftMajority = findMajorityUtil(arr, low, mid);` `    ``let rightMajority = findMajorityUtil(arr, mid+1, high);`   `    ``// If left and right halves have the ` `  ``// same majority element` `    ``if` `(leftMajority == rightMajority)` `        ``return` `leftMajority;`   `    ``// Count the occurrences of the` `  ``// majority element in entire array` `    ``let leftCount = countOccurrences(arr, high-low+1, leftMajority);` `    ``let rightCount = countOccurrences(arr, high-low+1, rightMajority);`   `    ``// Return the element that occurs` `  ``// more than n/2 times` `    ``if` `(leftCount > Math.floor((high-low+1) / 2))` `        ``return` `leftMajority;` `    ``if` `(rightCount > Math.floor((high-low+1) / 2))` `        ``return` `rightMajority;`   `    ``// No majority element` `    ``return` `-1;` `}`   `// Function to find the majority element` `function` `findMajority(arr, n) {` `    ``let majority = findMajorityUtil(arr, 0, n-1);` `    ``if` `(majority != -1)` `        ``document.write(majority);` `    ``else` `        ``document.write(``"No Majority Element"``);` `}`   `// Driver Code` `let arr = [1, 3, 3, 3, 2];` `let n = arr.length;`   `findMajority(arr, n);`

Output

```3

```

Time Complexity: O(N*log N)
Space Complexity: O(log N)

Previous
Next