Majority Element In an Array in Java

It is a very interesting problem frequently asked in interviews of top IT companies like Google, Amazon, TCS, Accenture, etc. By solving the problem, one wants to check the logical ability, critical thinking, and problem-solving skill of the interviewee. So, in this section, we are going to find majority element in an array in Java with different approaches and logic. Also, we will create Java programs for the same.

Problem Statement

An array containing integers is given. Our task is to find the majority of elements present in the input array.

Majority Element

A majority element is an element whose number of occurrences is greater than half of the size of the input array.

Example 1:

Input:

Int arr[] = {5, 1, 1, 1, 1, 1, 4, 9, 1, 0, 1, -2}

Output: 1

Explanation: The count of occurrence of element 1 is 7, which is greater than half of the size of the input array, which is (12 / 2) = 6.

Example 2:

Input:

Int arr[] = {47, 8, 1, 6, 3, 6, 90, 52, 78, 47, 47, 47}

Output: No majority element exists in the input array.

Explanation: There is no element whose count of occurrence is more than half of the size of the input array.

Naive Approach

In this approach, we will take two nested loops. The outer loop will pick an element from the input array (from left to right). The inner loop will count the occurrence of the element picked by the outer loop. If the count is greater than half of the size of the input array, then we have our answer. If not, then consider the next iteration and so on. If the outer loop terminates, then it means all the elements of the input array have been exhausted, and the majority element is not found.

FileName: MajorityEle.java

public class MajorityEle
{
    // a method the looks for the majority element
    // in the array arr
    public int findMajorEle(int inputArr[])
    {
        int s = inputArr.length;
        
        int count = 0;
        
        // outer loop picks the element
        for(int i = 0 ; i < s; i++)
        {
            // the inner loop counts the occurrence 
            // of the element input[i]
            for(int j = 0; j < s; j++)
            {
                if(inputArr[i] == inputArr[j])
                {
                    count = count + 1;
                }
            }
            
            // if count is greater than half of s,
            // we have our answer
            if(count > s / 2)
            {
                return inputArr[i];
            }
            
            // resetting the count to 0
            count = 0;
        }
        
        // if the control reaches here,
        // then it means there is no majority element 
        // in the array arr
        return -1;
    }

    // main method
    public static void main(String[] argvs) 
    {
        // creating an object of the class MajorityEle
        MajorityEle obj = new MajorityEle();

        // input array
        int arr[] = {5, 1, 1, 1, 1, 1, 4, 9, 1, 0, 1, 2};
        
        int s = arr.length;
        System.out.println("For the input array.");
        for(int i = 0; i < s; i++)
        {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
        int ans = obj.findMajorEle(arr);
        if(ans != -1)
        {
           System.out.println("The majority element is: " + ans); 
        }
        else
        {
            System.out.println("The majority element is not found."); 
        }
        
        
        System.out.println("\n");
        
        // another input array
        int arr1[] = {47, 8, 1, 6, 3, 6, 90, 52, 78, 47, 47, 47};
        
        s = arr1.length;
        System.out.println("For the input array.");
        for(int i = 0; i < s; i++)
        {
            System.out.print(arr1[i] + " ");
        }
        System.out.println();
        ans = obj.findMajorEle(arr1);
        if(ans != -1)
        {
           System.out.println("The majority element is: " + ans); 
        }
        else
        {
            System.out.println("The majority element is not found."); 
        }
        
        
    }

}

Output:

For the input array.
5 1 1 1 1 1 4 9 1 0 1 2 
The majority element is: 1


For the input array.
47 8 1 6 3 6 90 52 78 47 47 47 
The majority element is not found.

Complexity Analysis: The program is using nested loops. Therefore, the time complexity of the program is O(n²), where n is the total number of elements present in the input array. The time complexity of the program is O(1), as the program is not using any extra space.

Approach: Using Binary Search Tree

In this approach, we will insert the elements of the input array one by one and if the element is already present in the Binary Search Tree, then increase its count. At any stage, if the count of any node becomes greater than half of the size of the input array, then we have our answer.

Algorithm

Observe the following algorithm.

Step 1: Construct a BST (Binary search tree); if the same element is entered again in the BST, then the count of the occurrence of the node is increased.

Step 2: Traverse the input array and put the element in the BST.

Step 3: If the maximum occurrence of any of the nodes is more than the half of the size of the input array, then do an in order traversal to find the node with an occurrence count of more than the half

Step 4: Else, print the appropriate message for the no majority element.

FileName: MajorityEle1.java

class Node
{
	int val;
	int freqCount = 0;
	Node l;
	Node r;
	
}
public class MajorityEle1
{
	
int maxCount = 0;

// A utility method for creating a
// new BST node
public Node newNde(int val)
{
	Node tmp = new Node();
	tmp.val = val;
	tmp.freqCount = 1;
	tmp.l = tmp.r = null;
	return tmp;
}

// A utility method for inserting a new node
// with the provided key in the BST
public Node insertNode(Node nde, int key)
{
	
	// If the tree has no node then,
	// a new node is returned
	if (nde == null)
	{
		if (maxCount == 0)
		{
		     
			maxCount = 1;
		}

		return newNde(key);
	}
	
	// Otherwise, recursively go down the Binary Search Tree
	
	// node value less than the current node value 
	// goes in the left subtree
	if (key < nde.val)
	{
		nde.l = insertNode(nde.l, key);
	}
	// node value more than the current node value 
	// goes in the right subtree
	else if (key > nde.val)
	{
		nde.r = insertNode(nde.r, key);
	}
	else
	{
	    nde.freqCount = nde.freqCount + 1;
	}

	// Finding the maximum count
	maxCount = Math.max(maxCount, nde.freqCount);

	// Returning the node pointer
	return nde;
}
int ans = -1;
// A utility method for performing the inorder
// traversal of the BST
public int inorderTravsersal(Node rt, int s)
{
	if (rt != null)
	{
		inorderTravsersal(rt.l, s);

		if (rt.freqCount > (s / 2))
		{
		    ans = rt.val;
			return rt.val;
		}

		inorderTravsersal(rt.r, s);
	}
	
	return ans;
}

// main method
    public static void main(String[] argvs) 
    {
        // creating an object of the class MajorityEle1
        MajorityEle1 obj = new MajorityEle1();

        // input array
        int arr[] = {5, 1, 1, 1, 1, 1, 4, 9, 1, 0, 1, 2};
        Node rt = null;
        int s = arr.length;
        System.out.println("For the input array.");
        for(int i = 0; i < s; i++)
        {
            System.out.print(arr[i] + " ");
            rt = obj.insertNode(rt, arr[i]);
        }
        System.out.println();
        int ans = obj.inorderTravsersal(rt, s);
        if(ans != -1)
        {
           System.out.println("The majority element is: " + ans); 
        }
        else
        {
            System.out.println("The majority element is not found."); 
        }
        
        
        System.out.println("\n");
        
        rt = null;
        obj.maxCount = 0;
        obj.ans = -1;
        
        // another input array
        int arr1[] = {47, 8, 1, 6, 3, 6, 90, 52, 78, 47, 47, 47};
        
        s = arr1.length;
        System.out.println("For the input array.");
        for(int i = 0; i < s; i++)
        {
            System.out.print(arr1[i] + " ");
            rt = obj.insertNode(rt, arr1[i]);
        }
        System.out.println();
        ans = obj.inorderTravsersal(rt, s);
        if(ans != -1)
        {
           System.out.println("The majority element is: " + ans); 
        }
        else
        {
            System.out.println("The majority element is not found."); 
        }

        
    }

}

Output:

For the input array.
5 1 1 1 1 1 4 9 1 0 1 2 
The majority element is: 1


For the input array.
47 8 1 6 3 6 90 52 78 47 47 47 
The majority element is not found.

Complexity Analysis: The time complexity of the program is the same as the previous program. The space complexity of the program is O(n), where n is the total number of elements present in the input array. The space complexity is due to the construction of the Binary Search Tree for storing the nodes.

Approach: Using Sorting

Sorting will group the elements of the same value together. After sorting, all one has to do is take the count of the elements of the same value and check whether it is more than half of the size of the input array or not. The following program illustrates the same.

FileName: MajorityEle2.java

// important import statement
import java.util.Arrays;

public class MajorityEle2
{
	
// a method for finding the major elements
// in the array arr[]
public int findMajorEle(int arr[])
{
int size = arr.length;

// Sorting the array
Arrays.sort(arr);
int count = 1;
for(int i = 1; i < size; i++)
{
    if(arr[i] == arr[i - 1])
    {
        // finding the count of the elements
        // that have the same value
        count = count + 1;
    }
    else
    {
        // if the value of the count is more than 
        // the half of the size of the input array,
        // then the majority element is found and we return 1
        if(count > (size / 2))
        {
            return 1;
        }
        count = 1;
    }
}

// the last group of elements of the same value 
// can also be the majority element
// this check is especially for that last group
if(count > (size / 2))
{
    return 1;
}

// if the control reaches here, then it means
// the majority element is not found.
return -1;

}

// main method
public static void main(String[] argvs) 
{
    // creating an object of the class MajorityEle2
    MajorityEle2 obj = new MajorityEle2();

    // input array
    int arr[] = {5, 1, 1, 1, 1, 1, 4, 9, 1, 0, 1, 2};
    int s = arr.length;
    System.out.println("For the input array.");
    for(int i = 0; i < s; i++)
    {
        System.out.print(arr[i] + " ");
    }
    System.out.println();
    int ans = obj.findMajorEle(arr);
    if(ans != -1)
    {
       System.out.println("The majority element is: " + ans); 
    }
    else
    {
        System.out.println("The majority element is not found."); 
    }
    
    
    System.out.println("\n");
    
    // another input array
    int arr1[] = {47, 8, 1, 6, 3, 6, 90, 52, 78, 47, 47, 47};
    
    s = arr1.length;
    System.out.println("For the input array.");
    for(int i = 0; i < s; i++)
    {
        System.out.print(arr1[i] + " ");
    }
    System.out.println();
    ans = obj.findMajorEle(arr1);
    if(ans != -1)
    {
       System.out.println("The majority element is: " + ans); 
    }
    else
    {
        System.out.println("The majority element is not found."); 
    }

    
}

}

Output:

For the input array.
5 1 1 1 1 1 4 9 1 0 1 2 
The majority element is: 1


For the input array.
47 8 1 6 3 6 90 52 78 47 47 47 
The majority element is not found.

Complexity Analysis: Since the program is using sorting, the time complexity of the program is O(n * log(n)), where n is the total number of elements present in the input array. The space complexity of the program is constant, i.e., O(1).

Approach: Using HashMap

The approach is quite straightforward. Observe the following steps.

Step 1: Count the frequency of occurrence of the array elements.

Step 2: Store the array element and its occurrence count as the key-value pair in a hash map.

Step 3: Iterate over the hashmap and check if the value of the frequency count of the element is greater than half of the size of the input array or not.

Step 4: Display the output.

Look at the following program.

FileName: MajorityEle3.java

// important import statement
import java.util.HashMap;

public class MajorityEle3
{
	
// a method for finding the major elements
// in the array arr[]
public int findMajorEle(int arr[])
{
int size = arr.length;

HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();

for(int i = 1; i < size; i++)
{
if(hm.containsKey(arr[i])) 
{
    int count = hm.get(arr[i]) + 1;
    if (count > arr.length / 2) 
    {
        
        return arr[i];
    }
    
    else
    {
        hm.put(arr[i], count);
    }
 
}
else
{
    hm.put(arr[i], 1);
}
}

// if the control reaches here, then it means
// the majority element is not found.
return -1;

}



// main method
public static void main(String[] argvs) 
{
    // creating an object of the class MajorityEle3
    MajorityEle3 obj = new MajorityEle3();

    // input array
    int arr[] = {5, 1, 1, 1, 1, 1, 4, 9, 1, 0, 1, 2};
    int s = arr.length;
    System.out.println("For the input array.");
    for(int i = 0; i < s; i++)
    {
        System.out.print(arr[i] + " ");
    }
    System.out.println();
    int ans = obj.findMajorEle(arr);
    if(ans != -1)
    {
       System.out.println("The majority element is: " + ans); 
    }
    else
    {
        System.out.println("The majority element is not found."); 
    }
    
    
    System.out.println("\n");
    
    // another input array
    int arr1[] = {47, 8, 1, 6, 3, 6, 90, 52, 78, 47, 47, 47};
    
    s = arr1.length;
    System.out.println("For the input array.");
    for(int i = 0; i < s; i++)
    {
        System.out.print(arr1[i] + " ");
    }
    System.out.println();
    ans = obj.findMajorEle(arr1);
    if(ans != -1)
    {
       System.out.println("The majority element is: " + ans); 
    }
    else
    {
        System.out.println("The majority element is not found."); 
    }

    
}

}

Output:

For the input array.
5 1 1 1 1 1 4 9 1 0 1 2 
The majority element is: 1


For the input array.
47 8 1 6 3 6 90 52 78 47 47 47 
The majority element is not found.

Complexity Analysis: Since the program is using only one loop, the time complexity of the program is O(n). The program is also using a hash map. Thus, making the space complexity of the program O(n), where n is the total number of elements present in the input array.

Approach: Using Moore's Voting Technique

Observe the following steps.

Step 1: Iterate over the elements to maintain the count of the majority element and the index, which is majIndex in our case.

Step 2: If the next element has the same value as the current element, then increase the count by 1.

Step 3: If the next element does not have the same value as the current element, then decrease the count by 1.

Step 4: If the count becomes 0, then update the majIndex by assigning the index of the current element and assigning the value 1 to the count.

Step 5: Pick the element pointed by majIndex, and find the count of occurrence of the element.

Step 6: If the count is greater than half of the size of the input array, then the element pointed by the majIndex is the majority element; otherwise, the majority element does not exist in the input array.

Look at the following program.

FileName: MajorityEle4.java

public class MajorityEle4
{
	
// a method for finding the major elements
// in the array arr[]
public int findMajorEle(int arr[])
{
int size = arr.length;

// points to the element 
// that can be the majority element
int majIndex = 0;
int cnt = 1;
int j;
for (j = 1; j < size; j++) 
{
	if (arr[majIndex] == arr[j])
	{
	    // if the current element is same 
	    // increament the count by 1
		cnt = cnt + 1;
	}
	else
	{
	    // if the current element is not same 
	    // decrease the count by 1
		cnt = cnt - 1;
	}
	if (cnt == 0) 
	{
	    // if the count is zero then the 
	    // element pointed by majIndex
	    // can never the answer. Hence, we
	    // update the count as well the majIndex
		majIndex = j;
		cnt = 1;
	}
}


if(isMajor(arr, arr[majIndex]))
{
    return arr[majIndex];
}

return -1;

}



// a method that checks whether ele is the major element
// present in the array arr or not
public boolean isMajor(int arr[], int ele)
{
    int s = arr.length;
    
    int cnt = 0;
    
    for(int i = 0 ; i < s; i++)
    {
        if(ele == arr[i])
        {
            cnt  = cnt + 1;
        }
    }
    
    // as per the definition,
    // cnt has to more that half of the size of 
    // the  input array
    if(cnt > (s / 2))
    {
        return true;
    }
    
    return false;
}



// main method
public static void main(String[] argvs) 
{
    // creating an object of the class MajorityEle4
    MajorityEle4 obj = new MajorityEle4();

    // input array
    int arr[] = {5, 1, 1, 1, 1, 1, 4, 9, 1, 0, 1, 2};
    int s = arr.length;
    System.out.println("For the input array.");
    for(int i = 0; i < s; i++)
    {
        System.out.print(arr[i] + " ");
    }
    System.out.println();
    int ans = obj.findMajorEle(arr);
    if(ans != -1)
    {
       System.out.println("The majority element is: " + ans); 
    }
    else
    {
        System.out.println("The majority element is not found."); 
    }
    
    
    System.out.println("\n");
    
    // another input array
    int arr1[] = {47, 8, 1, 6, 3, 6, 90, 52, 78, 47, 47, 47};
    
    s = arr1.length;
    System.out.println("For the input array.");
    for(int i = 0; i < s; i++)
    {
        System.out.print(arr1[i] + " ");
    }
    System.out.println();
    ans = obj.findMajorEle(arr1);
    if(ans != -1)
    {
       System.out.println("The majority element is: " + ans); 
    }
    else
    {
        System.out.println("The majority element is not found."); 
    }

    
}

}

Output:

For the input array.
5 1 1 1 1 1 4 9 1 0 1 2 
The majority element is: 1


For the input array.
47 8 1 6 3 6 90 52 78 47 47 47 
The majority element is not found.

Complexity Analysis: The time complexity of the program is the same as the previous program. As the program is not using any data structure, the space complexity of the program is O(1).

Next TopicBlock Swap Algorithm or Array Rotation in Java

← prev next →

For Videos Join Our Youtube Channel: Join Now

Feedback

Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Splunk

SPSS

Swagger

Transact-SQL

Tumblr

ReactJS

Regex

Reinforcement Learning

R Programming

RxJS

React Native

Python Design Patterns

Python Pillow

Python Turtle

Keras

Preparation

Aptitude

Reasoning

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

AWS

Selenium

Cloud Computing

Hadoop

ReactJS

Data Science

Angular 7

Blockchain

Git

Machine Learning

DevOps

B.Tech / MCA

DBMS

Data Structures

DAA

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

Automata

C Programming

C++

Java

.Net

Python

Programs

Control System

Data Mining

Data Warehouse

Javatpoint Services

JavaTpoint offers too many high quality services. Mail us on [email protected], to get more information about given services.

Website Designing
Website Development
Java Development
PHP Development
WordPress
Graphic Designing
Logo
Digital Marketing
On Page and Off Page SEO
PPC
Content Development
Corporate Training
Classroom and Online Training
Data Entry

Training For College Campus

JavaTpoint offers college campus training on Core Java, Advance Java, .Net, Android, Hadoop, PHP, Web Technology and Python. Please mail your requirement at [email protected]
Duration: 1 week to 2 week

^{Like/Subscribe us for latest updates or newsletter}