如何从int类型的方法返回多个整数

Question

如标题所述，我正在尝试从int类型的方法(int模式(int[]a)返回多个整数。该方法旨在接受整数数组并确定模式。另一个问题是int[]a索引中的每个值的范围为1-3。我无法创建对象、其他方法来处理部分解决方案或导入任何帮助我的东西。

我遇到的问题是如果数组中有多个模式

即int[]array={1,2,2,3,3,4,5,6}

如您所见，在本例中有两种模式，分别是2和3，我不知道如何从一个方法返回多个整数。

这是我教授的指示“

“编写方法int mode(int[]a)。此函数采用一个数组a的索引范围从1到a.Length。a的每个单元格都包含1、2或3。您的函数返回数组a中最常出现的值（1,2,3）。您应该不使用任何导入（即Math,arraylists等）或更改返回类型。假设main只包含一个数组，然后调用main中使用上述数组的mode方法。下面是模板：”

int模式(int[]a){

}

下面是我的代码的样子：

public static int mode(int [] a){

int value = 0;
int countOne= 0;
int countTwo = 0;
int countThr = 0;

for(int i =0;i<a.length;i++){
    int count = 0;
    for(int j=i+1;j<a.length;j++){
        if(a[i] == a[j]){
            if(a[i] == 1){
                countOne++;
            }
            if(a[i] == 2){
                countTwo++;
            }   
            if(a[i] == 3){
                countThr++;
            }
        }

    }
}
   if(countOne > countTwo && countOne > countThr)
       value = countOne;
   if(countTwo > countOne && countTwo > countThr){
       value = countTwo;
   }
   if(countThr > countOne && countThr > countTwo){
       value = countThr;
   }
   /* if(countThr == countTwo){
          return countThr, countTwo;
   if(countOne == countTwo){
          //return countOne, countTwo;
   if(countOne == countThree){
          return countOne, countThree;
      */       

   return value;

`

main{int[]a={1,2,2,3,3}；system.out.println（modeTwo(a)）；

输出:3

虽然三是部分正确的，因为有多个模式，在这种情况下，我希望的输出是

所需输出：2 3

在mode方法中，我只是为1-3创建一个计数器，看看每一个在数组中出现的次数。然后我设置条件来检查哪一个是最大的。我试图创建条件来检查它们是否相等，但是这不会起作用，因为我必须返回两个整数。我只是完全迷失了。如有任何帮助，我们将不胜感激。

int模式(int[]a){

}

Answer 1

考虑到您关于无法使用数组列表或导入其他库的更新，我创建了一个用于计算出现次数的自定义类modes，并且仅使用数组来计算每个数字的最大出现次数，但只返回出现次数等于最大出现次数的int[]中的数字。

下面是我想出的方法，它将计算数组中每个数字的所有出现次数，并返回出现次数最多的每个数字，这与模式相同。

   public static void main(String eth[]) {
        int[] numbers = new int[] {1, 2, 2, 3, 3, 4, 4, 5, 5, 10, 12, 33};
        int[] modes = mode(numbers);

        for (int i = 0; i < modes.length; i++) {
            if (modes[i] == -999) { // Stop printing once you reach the first sentinal value
                continue;
            }
            System.out.println(modes[i]);
        }
    }

    private static int[] mode(int[] numbers) {
        Modes[] modes = new Modes[numbers.length];
        int modesIndex = 0;

        int maxOccurrence = 0;
        for (int i = 0; i < numbers.length; i++) {
            if (numbers[i] == -999) {
                continue;
            }

            int number = numbers[i];
            numbers[i] = -999; // -999 is a sentinel value

            int count = 1;
            for (int j = i + 1; j < numbers.length; j++) {
                if (numbers[j] == -999) {
                    continue;
                }

                if (numbers[j] == number) {
                    numbers[j] = -999;
                    count++;
                }
            }
            if (count > maxOccurrence) {
                maxOccurrence = count;
            }
            modes[modesIndex++] = new Modes(number, count);
        }

        int[] result = new int[numbers.length];
        for (int i = 0; i < result.length; i++) {
            result[i] = -999; // Sentinel value
        }

        int index = 0;
        for (int i = 0; i < modes.length; i++) {
            if (modes[i] == null) {
                break; // Stop when you hit the first null
            }
            if (modes[i].Occurrences == maxOccurrence) {
                result[index] = modes[i].Number;
                index++;
            }
        }

        return result;
    }

    public static class Modes {
        public int Number;
        public int Occurrences;

        public Modes(int number, int occurrences) {
            Number = number;
            Occurrences = occurrences;
        }
    }

结果：