Degree of an Array

Given a non-empty array of non-negative integers nums, the degree of this array is defined as the maximum frequency of any one of its elements.

Your task is to find the smallest possible length of a (contiguous) subarray of nums, that has the same degree as nums.

Example 1:

Input: [1, 2, 2, 3, 1]
Output: 2
Explanation: 
The input array has a degree of 2 because both elements 1 and 2 appear twice.
Of the subarrays that have the same degree:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
The shortest length is 2. So return 2.

Example 2:

Input: [1,2,2,3,1,4,2]
Output: 6

Note:

• nums.length will be between 1 and 50,000.
• nums[i] will be an integer between 0 and 49,999.

class Solution {
    public int findShortestSubArray(int[] nums) {
        // maps number with [count, startIndex, endIndex]
        HashMap<Integer, int[]> map = new HashMap<Integer, int[]>();
        
        int result = Integer.MAX_VALUE, maxCount = 0;
        for (int i = 0; i < nums.length; i++) {
            int[] numData = new int[3];
            if (map.containsKey(nums[i])) {
                int[] temp = map.get(nums[i]);
                numData[0] = temp[0] + 1;
                numData[1] = temp[1];
            } else {
                numData[0] = 1;
                numData[1] = i;
            }
            numData[2] = i;
            map.put(nums[i], numData);
                
            if (numData[0] > maxCount) {
                maxCount = numData[0];
                result = numData[2] - numData[1] + 1;
            } else if (numData[0] == maxCount) {
                result = Math.min(result, numData[2] - numData[1] + 1);
            }
        }
        
        return result;
    }
}