Question

假设我有一个像这样的整数数组： {5,3,5,4,2}

我有一个方法可以返回最常见的字符

public int highestnumber(String[] num) {

        int current_number = Integer.parseInt(num[0]);
        int counter = 0;
        for (int i = 1; i < num.length; ++i) {
            if (current_number == Integer.parseInt(num[i])) {
                ++counter;

            } else if (counter == 0) {
                current_number = Integer.parseInt(num[i]);
                ++counter;

            } else {
                --counter;

            }
        }

        return current_number;
    }

但如果我有多个共同字符，那么我需要得到最接近一（1）的数字，就像我有这样的数组： {5,5,4,4,2};

那么该方法应该返回4，我该怎么做呢？

Answer 1

根据我的理解你的问题，

你要做的是，

1. Create ArrayList from your int[]
2. Use HashMap for find duplicates, which one is unique
3. Sort it as Ascending order, 
4. First element is what you want..

编辑：回答您的问题

int[] arr = {5, 4, 5, 4, 2};
ArrayList<Integer> resultArray = new ArrayList<Integer>();
Set<Integer> set = new HashSet<Integer>();

for (int i = 0; i < arr.length; i++)
    {
     if (set.contains(arr[i]))
    {
     System.out.println("Duplicate value found at index: " + i);
     System.out.println("Duplicate value: " + arr[i]);
         resultArray.add(arr[i]);
    }
    else
    {
    set.add(arr[i]);
    }
   }
Collections.sort(resultArray);

for (int i = 0; i < resultArray.size(); i++)
{
Log.e("Duplicate Values:", resultArray.get(i) + "");
}

您的需求是，

int values = resultArray.get(0);

Answer 2

对数组进行排序，然后计算值的运行次数。

Answer 3

快捷方式。为每个数字创建一个计数器int数组元素。遍历数组一次并为每个数字增加相应的计数器数组。将最高编号设置为第一个计数器元素然后通过并将最大数字更改为当前元素，只要它大于最大数字，返回最高编号。

public int highestNumber(String[] num){
    int[] count = new int[10];
    int highest_number = 0;
    int highest_value = 0;

    for(int i = 0; i < num.length; i++)
        count[Integer.parseInt(num[i])]++;;

    for(int i = 0; i < count.length; i++)
        if(count[i] > highest_value){
            highest_number = i;
            highest_value = count[i];
        }

    return highest_number;
}

慢10倍但没有其他阵列。创建三个整数，一个用于数字，两个用于计数。对每个int进行一次数组运算，并在每次显示时增加当前计数，如果最大计数值更大，设置为最高计数并将最高数量设置为当前计数。返回最高数字。

public int highestNumber(String[] num){
    int highest_number = 0;
    int highest_value = 0;
    int current_value = 0;

    for(int i = 0; i < 10; i++){
        for(int j = 0; j < num.length; j++)
            if(i == Integer.parseInt(num[j]))
                current_value++;

        if(current_value > highest_value){
            highest_value = current_value;
            highest_number = i;
        }

        current_value = 0;
    }

    return highest_number;
}

第一个显然要快得多但如果出于某种原因你不想要另一个阵列，那么第二个阵列也会起作用。

Answer 4

你也可以试试这个：

import java.util.TreeMap;

public class SmallestFrequentNumberFinder {

    public static int[] stringToIntegerArray(String[] stringArray) {
        int[] integerArray = new int[stringArray.length];
        for (int i = 0; i < stringArray.length; i++) {
            integerArray[i] = Integer.parseInt(stringArray[i]);
        }
        return integerArray;
    }

    public static int getSmallestFrequentNumber(int[] numbers) {
        int max = -1;
        Integer smallestFrequentNumber = null;
        TreeMap<Integer, Integer> frequencyMaper = new TreeMap<Integer, Integer>();

        for (int number : numbers) {
            Integer frequency = frequencyMaper.get(number);
            frequencyMaper.put(number, (frequency == null) ? 1 : frequency + 1);
        }

        for (int number : frequencyMaper.keySet()) {
            Integer frequency = frequencyMaper.get(number);
            if (frequency != null && frequency > max) {
                max = frequency;
                smallestFrequentNumber = number;
            }
        }
        return smallestFrequentNumber;
    }

    public static void main(String args[]) {
        String[] numbersAsString = {"5", "5", "4", "2", "4", "4", "2", "2"};
        final int[] integerArray = stringToIntegerArray(numbersAsString);
        System.out.println(getSmallestFrequentNumber(integerArray));
    }
}

如何获得数组中最常见的字符？

4 个答案: