Finding the mode of elements in a multidimensional Java array

05 Oct 2023

Introduction

In Java, you may come across scenarios where you need to find the mode of elements in a multidimensional array. The mode represents the value(s) that occur(s) most frequently in the array. This can be a useful task when analyzing data or working with statistics.

In this blog post, we will explore how to find the mode of elements in a multidimensional Java array. We will discuss the steps involved and provide a code example to illustrate the process.

Steps to Find the Mode

Create a HashMap to store the elements of the array as keys, and their frequencies as values.
Iterate over each element in the multidimensional array.
For each element, check if it already exists as a key in the HashMap.
- If it exists, increment the frequency value by 1.
- If it doesn’t exist, add it to the HashMap with a frequency of 1.
After iterating over all the elements, find the maximum frequency value in the HashMap.
Iterate over the HashMap and find the keys that have the maximum frequency.
Store these keys representing the mode in a separate array or list.

Example Code

import java.util.HashMap;
import java.util.Map;

public class ModeFinder {
    public static int[] findMode(int[][] array) {
        // Step 1: Create HashMap
        Map<Integer, Integer> frequencyMap = new HashMap<>();

        // Step 2: Iterate over each element
        for (int[] row : array) {
            for (int element : row) {
                // Step 3: Update frequencies in HashMap
                if (frequencyMap.containsKey(element)) {
                    frequencyMap.put(element, frequencyMap.get(element) + 1);
                } else {
                    frequencyMap.put(element, 1);
                }
            }
        }

        // Step 4: Find maximum frequency
        int maxFrequency = 0;
        for (int frequency : frequencyMap.values()) {
            if (frequency > maxFrequency) {
                maxFrequency = frequency;
            }
        }

        // Step 5: Find mode keys
        int modeCount = 0;
        for (int key : frequencyMap.keySet()) {
            if (frequencyMap.get(key) == maxFrequency) {
                modeCount++;
            }
        }

        // Step 6: Store mode keys in an array
        int[] modeArray = new int[modeCount];
        int index = 0;
        for (int key : frequencyMap.keySet()) {
            if (frequencyMap.get(key) == maxFrequency) {
                modeArray[index++] = key;
            }
        }

        return modeArray;
    }

    public static void main(String[] args) {
        int[][] array = {{1, 2, 2}, {3, 4, 4, 4}, {5, 5, 6, 6, 6, 6}};
        int[] mode = findMode(array);

        System.out.println("Mode(s) of the array:");
        for (int value : mode) {
            System.out.println(value);
        }
    }
}

Conclusion

Finding the mode of elements in a multidimensional Java array can be achieved by using a HashMap to keep track of the frequencies. By iterating over the array and updating the frequencies in the HashMap, we can then find the mode by identifying the keys with the maximum frequency.

By following the steps outlined in this blog post and using the provided code example, you can easily find the mode of elements in a multidimensional Java array. This knowledge can be valuable when working with data analysis or statistics in your Java applications.