LeetCode 229. Majority Element II (Medium)

Leetcode 229. Majority Element II:Hey there, coding enthusiasts! Welcome back to another exciting coding session. Today’s problem is a treat—literally! We’re going to solve the “Majority Element II” or “LeetCode 229. ‘ 

Leetcode 229Majority Element II
Leet code 229 Majority Element II

Method : HashMap Approach – Majority Element II

1: Initialize Data Structures

  • Begin by creating the necessary data structures such as vectors (C++), lists (Java), arrays (Python), or objects (JavaScript) to store your results.

2: Count Element Occurrences

  • Utilize data structures like unordered_map (C++), HashMap (Java), Counter (Python), or Map (JavaScript) to count the occurrences/ Frequency of each element in the input array.

3: Calculate the Threshold

  • Determine the threshold, which is typically one-third of the array’s length. This threshold helps identify majority elements.

4: Iterate Over Counts

  • Iterate through the count data structure, checking the occurrence of each element.

5: Identify Majority Elements

  • If an element’s count surpasses the threshold, consider it a majority element and add it to the result.

6: Return the Result

  • Finally, return the result, containing all identified majority elements in the array.

LeetCode 15 : Three (3) Sum

Codes : HashMap Approach – Majority Element II

C++ : Majority Element II

#include <vector>
#include <unordered_map>

class Solution {
    std::vector<int> majorityElement(std::vector<int>& nums) {
        std::unordered_map<int, int> m;
        for (int i = 0; i < nums.size(); i++) {
        int threshold = nums.size() / 3;

        std::vector<int> result;
        for (auto& it : m) {
            int x = it.second;
            if (x > threshold) {
        return result;

Java: Leet code 229

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Solution {
    public List<Integer> majorityElement(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int num : nums) {
            map.put(num, map.getOrDefault(num, 0) + 1);
        int threshold = nums.length / 3;

        List<Integer> result = new ArrayList<>();
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            int count = entry.getValue();
            if (count > threshold) {
        return result;

Python: Leet Code 229

from collections import Counter

class Solution:
    def majorityElement(self, nums):
        counts = Counter(nums)
        threshold = len(nums) // 3

        result = []
        for num, count in counts.items():
            if count > threshold:

        return result

JavaScript: Majority Element II

 * @param {number[]} nums
 * @return {number[]}
var majorityElement = function(nums) {
        const counts = new Map();
        for (let num of nums) {
            counts.set(num, (counts.get(num) || 0) + 1);
        const threshold = Math.floor(nums.length / 3);

        const result = [];
        for (let [num, count] of counts.entries()) {
            if (count > threshold) {
        return result;

Result Analysis Leet code 229

Majority Element II

List of Some important Leet code Questions:

About Nilesh Raut

I am Nilesh,3+ years Exp of SEO, content writing, and keyword research. Also rocks it as a software dev with skills in OS, web dev, Flask, Python, C++, data structures, and algorithms. 3 on Leetcode, 5*on Hackerrank more platform.

Leave a Comment

Discover more from NileshBlog.Tech

Subscribe now to keep reading and get access to the full archive.

Continue Reading