# LeetCode – Majority Element (Java)

Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times. (assume that the array is non-empty and the majority element always exist in the array.)

Java Solution 1 - Sorting

Assuming the majority exists and since the majority always takes more than half of space, the middle element is guaranteed to be the majority. Sorting array takes O(nlog(n)). So the time complexity of this solution is nlog(n).

```public int majorityElement(int[] num) { if (num.length == 1) { return num; }   Arrays.sort(num); return num[num.length / 2]; }```

Java Solution 2 - Majority Vote Algorithm

This problem can be solved in time of O(n) with constant space complexity. The basic idea is that the majority element can negate all other element's count. ```public int majorityElement(int[] nums) { int result = 0, count = 0;   for(int i = 0; i<nums.length; i++ ) { if(count == 0){ result = nums[ i ]; count = 1; }else if(result == nums[i]){ count++; }else{ count--; } }   return result; }```

Reference:
A Linear Time Majority Vote Algorithm

Category >> Algorithms
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:
```<pre><code>
String foo = "bar";
</code></pre>
```
• arnavawasthi

``` public class MajorityElement {```

``` /** * Why this simple solution should work? * Theory: Either majority element will be the first element or there will at least one instance where at least two of them will * be at consecutive indices. * - When odd number of elements and there is a different number between each pair. One of the majority element will be at 0th pos. * - In all other cases, two or more of them will have to be on consecutive indices. * @param inputArr * @return */ public static int solution(int[] inputArr){ int majorityElem = inputArr; for(int i = 0; i < inputArr.length-1; i++){ if(inputArr[i] == inputArr[i+1]){ majorityElem = inputArr[i]; } } return majorityElem; } ```

``` public static void main(String[] args) { int a[] = new int[]{2,1,2,3,2,1,2}; System.out.println(solution(a)); } } ```

• Solved this in C, three different methods
http://algorithmsandme.in/2016/02/majority-element-in-an-array/

• Maxim Rubis

Your inputs are not correct, because there is no majority element in them.

“The majority element is the element that appears more than ⌊ n/2 ⌋ times. (assume that the array is non-empty and the majority element always exist in the array.)”

• Chaitra Deshpande

Solution 2(Much Simpler) does not work for all inputs.
Ex 1 : {2,2,2,2,6,7,4,4}; Ans :4
Ex 2: {7,7,7,3,4,4,2,2}; Ans : 4
and many more

• Kyle

Just iterate till end either to left or right.

• vvicazz

What if majority element is not present ? In that case your program will return wrong element.

• Han Wang

It’s a nice solution. But it requires O(N) extra space.

There is a standard O(n) algorithm for solving this problem. Its known as Moors’s Voting algorithm. The implementation for the same is given below

int Maj( int [] a, int n ) {

}

• jason zhang

Super!

• jason zhang

should be a special quickSelect problem

• Puneet

private static int returnMajorityElement(int[] array) {
HashMap arrayElementsCounts = new HashMap();
for (int i = 0; i < array.length; i++) {
int elementCount = 1;
if (arrayElementsCounts.containsKey(array[i])) {
elementCount = arrayElementsCounts.get(array[i]) + 1;
}

arrayElementsCounts.put(array[i], elementCount);
}
// iterate arrayElementsCounts to find the majorityElement
Iterator iterateArrayElementsCounts = arrayElementsCounts.entrySet().iterator();
while (iterateArrayElementsCounts.hasNext()) {
Map.Entry entry = (Map.Entry) iterateArrayElementsCounts.next();
if (entry.getValue() > (array.length / 2)) { // return majorityElement
return entry.getKey();
}
}

// majority element doesn’t exist
return 0;
}

• ryanlr

Great solution!

• SK

It can be simplified. After sorting the array, the majority of the element should be in the middle of the array [or one less from the middle]. Because majority element always more than n/2.

public class Solution {
public int majorityElement(int[] num) {
if(num.length==1){
return num;
}

Arrays.sort(num);

return num[num.length/2];
}
}