2

假设我有一个这样的整数数组：{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，我该怎么办？

4

4 回答 4

2

根据我对你的问题的理解，

你要做的是，

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);
于 2012-05-05T05:59:05.380 回答
2

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

于 2012-05-05T06:02:28.507 回答
1

你也可以试试这个：

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));
    }
}
于 2012-05-05T12:27:44.967 回答
1

快速的方式。为每个数字创建一个计数器 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;
}

第一个显然要快得多，但是如果出于某种原因您不想要另一个数组，第二个也可以使用。

于 2012-05-05T07:03:36.633 回答