Max Repeating in a Limited Range Array

Last Updated : 3 May, 2026

Given an array arr[]. The array contains numbers ranging from 0 to k-1 where k is a positive integer. Find the maximum repeating number in this array. If there are two or more maximum repeating numbers, return the element with the least value.

Input: k = 3, arr[] = [2, 2, 1, 2]
Output: 2
Explanation: 2 is the most frequent element.

Input: k = 3, arr[] = [2, 2, 1, 0, 0, 1]
Output: 0
Explanation: 0, 1, and 2 all have the same frequency of 2. But since 0 is the smallest, you need to return 0.

Try It Yourself
redirect icon

Table of Content

[Naive Approach] Two Nested Loops- O(nÂē) Time and O(1) Space

We check the frequency of each element by comparing it with every other element. The element with the highest frequency is selected, and in case of a tie, the smaller element is chosen.

C++ 
#include <iostream>
#include <vector>
using namespace std;

// Function to find maximum repeating element (naive)
int maxRepeating(int k, vector<int>& arr) {
    
    int n = arr.size();
    int maxCount = 0;
    int result = arr[0];

    // Pick each element
    for (int i = 0; i < n; i++) {
        int count = 0;

        // Count frequency of arr[i]
        for (int j = 0; j < n; j++) {
            if (arr[j] == arr[i])
                count++;
        }

        // Update result
        if (count > maxCount) {
            maxCount = count;
            result = arr[i];
        }
        else if (count == maxCount && arr[i] < result) {
            result = arr[i];
        }
    }

    return result;
}

// Driver code
int main() {
    int k = 6;
    vector<int> arr = {2, 3, 3, 5, 3, 2};

    cout << maxRepeating(k, arr);

    return 0;
}
Java 
import java.util.*;

class GFG {

    // Function to find maximum repeating element (naive)
    static int maxRepeating(int k, int[] arr) {
        
        int n = arr.length;
        int maxCount = 0;
        int result = arr[0];

        // Pick each element
        for (int i = 0; i < n; i++) {
            int count = 0;

            // Count frequency of arr[i]
            for (int j = 0; j < n; j++) {
                if (arr[j] == arr[i])
                    count++;
            }

            // Update result
            if (count > maxCount) {
                maxCount = count;
                result = arr[i];
            }
            else if (count == maxCount && arr[i] < result) {
                result = arr[i];
            }
        }

        return result;
    }

    public static void main(String[] args) {
        int k = 6;
        int[] arr = {2, 3, 3, 5, 3, 2};

        System.out.println(maxRepeating(k, arr));
    }
}
Python 
# Function to find maximum repeating element (naive)
def maxRepeating(k, arr):
    
    n = len(arr)
    maxCount = 0
    result = arr[0]

    # Pick each element
    for i in range(n):
        count = 0

        # Count frequency of arr[i]
        for j in range(n):
            if arr[j] == arr[i]:
                count += 1

        # Update result
        if count > maxCount:
            maxCount = count
            result = arr[i]
        elif count == maxCount and arr[i] < result:
            result = arr[i]

    return result


# Driver code
k = 6
arr = [2, 3, 3, 5, 3, 2]

print(maxRepeating(k, arr))
C# 
using System;

class GFG {

    // Function to find maximum repeating element (naive)
    static int maxRepeating(int k, int[] arr) {
        
        int n = arr.Length;
        int maxCount = 0;
        int result = arr[0];

        // Pick each element
        for (int i = 0; i < n; i++) {
            int count = 0;

            // Count frequency of arr[i]
            for (int j = 0; j < n; j++) {
                if (arr[j] == arr[i])
                    count++;
            }

            // Update result
            if (count > maxCount) {
                maxCount = count;
                result = arr[i];
            }
            else if (count == maxCount && arr[i] < result) {
                result = arr[i];
            }
        }

        return result;
    }

    public static void Main() {
        int k = 6;
        int[] arr = {2, 3, 3, 5, 3, 2};

        Console.WriteLine(maxRepeating(k, arr));
    }
}
JavaScript 
// Function to find maximum repeating element (naive)
function maxRepeating(k, arr) {
    
    let n = arr.length;
    let maxCount = 0;
    let result = arr[0];

    // Pick each element
    for (let i = 0; i < n; i++) {
        let count = 0;

        // Count frequency of arr[i]
        for (let j = 0; j < n; j++) {
            if (arr[j] === arr[i])
                count++;
        }

        // Update result
        if (count > maxCount) {
            maxCount = count;
            result = arr[i];
        }
        else if (count === maxCount && arr[i] < result) {
            result = arr[i];
        }
    }

    return result;
}

// Driver code
let k = 6;
let arr = [2, 3, 3, 5, 3, 2];

console.log(maxRepeating(k, arr));

Output
3

[Better Approach] Using Frequency Array - O(n + k) Time and O(k) Space

Since elements lie in range 0 to k-1, we can directly use a frequency array of size k to count occurrences. Then we scan this array to find the element with maximum frequency, choosing the smallest element in case of a tie.

  • Create a frequency array of size k initialized with 0
  • Traverse the input array and increment frequency of each element
  • Initialize maxFreq = 0 and result = 0
  • Traverse frequency array from 0 to k-1
  • If current frequency is greater, update maxFreq and result
  • If frequency is equal, choose the smaller index
C++ 
#include <iostream>
#include <vector>
using namespace std;

int maxRepeating(int k, vector<int>& arr)
{
    // Frequency array of size k
    vector<int> freq(k, 0);

    // Count frequency of each element
    for (int i = 0; i < arr.size(); i++)
        freq[arr[i]]++;

    int maxFreq = 0;
    int result = 0;

    // Find element with maximum frequency
    // If tie choose smallest element
    for (int i = 0; i < k; i++)
    {
        if (freq[i] > maxFreq)
        {
            maxFreq = freq[i];
            result = i;
        }
        else if (freq[i] == maxFreq && i < result)
        {
            result = i;
        }
    }

    return result;
}

// Driver code
int main()
{
    int k = 71;

    vector<int> arr = {
        35, 4, 52, 55, 28, 68, 39, 67, 38, 29,
        26, 11, 69, 10, 16, 56, 10, 61, 70, 27,
        65, 53
    };

    cout << maxRepeating(k, arr);

    return 0;
}
Java 
import java.util.*;

class GFG {

    static int maxRepeating(int k, int[] arr)
    {
        // Frequency array of size k
        int[] freq = new int[k];

        // Count frequency of each element
        for (int i = 0; i < arr.length; i++)
            freq[arr[i]]++;

        int maxFreq = 0;
        int result = 0;

        // Find element with maximum frequency
        // If tie choose smallest element
        for (int i = 0; i < k; i++)
        {
            if (freq[i] > maxFreq)
            {
                maxFreq = freq[i];
                result = i;
            }
            else if (freq[i] == maxFreq && i < result)
            {
                result = i;
            }
        }

        return result;
    }

    public static void main(String[] args)
    {
        int k = 71;

        int[] arr = {
            35, 4, 52, 55, 28, 68, 39, 67, 38, 29,
            26, 11, 69, 10, 16, 56, 10, 61, 70, 27,
            65, 53
        };

        System.out.println(maxRepeating(k, arr));
    }
}
Python 
# Function to find maximum repeating element
def maxRepeating(k, arr):

    # Frequency array of size k
    freq = [0] * k

    # Count frequency of each element
    for i in range(len(arr)):
        freq[arr[i]] += 1

    maxFreq = 0
    result = 0

    # Find element with maximum frequency
    # If tie choose smallest element
    for i in range(k):
        if freq[i] > maxFreq:
            maxFreq = freq[i]
            result = i
        elif freq[i] == maxFreq and i < result:
            result = i

    return result


# Driver code
k = 71
arr = [
    35, 4, 52, 55, 28, 68, 39, 67, 38, 29,
    26, 11, 69, 10, 16, 56, 10, 61, 70, 27,
    65, 53
]

print(maxRepeating(k, arr))
C# 
using System;

class GFG {

    static int maxRepeating(int k, int[] arr)
    {
        // Frequency array of size k
        int[] freq = new int[k];

        // Count frequency of each element
        for (int i = 0; i < arr.Length; i++)
            freq[arr[i]]++;

        int maxFreq = 0;
        int result = 0;

        // Find element with maximum frequency
        // If tie choose smallest element
        for (int i = 0; i < k; i++)
        {
            if (freq[i] > maxFreq)
            {
                maxFreq = freq[i];
                result = i;
            }
            else if (freq[i] == maxFreq && i < result)
            {
                result = i;
            }
        }

        return result;
    }

    public static void Main()
    {
        int k = 71;

        int[] arr = {
            35, 4, 52, 55, 28, 68, 39, 67, 38, 29,
            26, 11, 69, 10, 16, 56, 10, 61, 70, 27,
            65, 53
        };

        Console.WriteLine(maxRepeating(k, arr));
    }
}
JavaScript 
// Function to find maximum repeating element
function maxRepeating(k, arr)
{
    // Frequency array of size k
    let freq = new Array(k).fill(0);

    // Count frequency of each element
    for (let i = 0; i < arr.length; i++)
        freq[arr[i]]++;

    let maxFreq = 0;
    let result = 0;

    // Find element with maximum frequency
    // If tie choose smallest element
    for (let i = 0; i < k; i++)
    {
        if (freq[i] > maxFreq)
        {
            maxFreq = freq[i];
            result = i;
        }
        else if (freq[i] === maxFreq && i < result)
        {
            result = i;
        }
    }

    return result;
}

// Driver code
let k = 71;

let arr = [
    35, 4, 52, 55, 28, 68, 39, 67, 38, 29,
    26, 11, 69, 10, 16, 56, 10, 61, 70, 27,
    65, 53
];

console.log(maxRepeating(k, arr));

Output
10

Exercise: The above solution prints only one repeating element and doesn't work if we want to print all maximum repeating elements. For example, if the input array is {2, 3, 2, 3}, the above solution will print only 3. What if we need to print both of 2 and 3 as both of them occur maximum number of times. Write a O(n) time and O(1) extra space function that prints all maximum repeating elements. (Hint: We can use maximum quotient arr[i]/n instead of maximum value in step 2).
Note that the above solutions may cause overflow if adding k repeatedly makes the value more than INT_MAX.  

Comment
Article Tags:
DSA
Arrays
Amazon

Explore