Подсчет вхождений целых чисел в массив

Я должен сказать, что мне потребовалось некоторое время, чтобы понять, что представляют собой две переменные count и countNum, возможно, необходимы некоторые комментарии. Но, наконец, я узнаю ошибку.

Предположим, что введите десять чисел: 5, 6, 7, 8, 5, 6, 7, 8, 5, 6

После сортировки numList равно: 5, 5, 5, 6, 6, 6, 7, 7, 8, 8

Массив count, возвращаемый occurrences(), должен быть: [1, 2, 3, 1, 2, 3, 1, 2, 1, 2]

Фактически единственными полезными числами в этом массиве результатов являются:

count[2]: 3     count number for numList[2]: 5
count[5]: 3     count number for numList[5]: 6
count[7]: 2     count number for numList[7]: 7
count[9]: 2     count number for numList[9]: 8

Другие числа, такие как первые два числа 1, 2 перед 3, используются только для постепенного вычисления суммы вхождений, верно? Итак, ваша логика цикла должна быть изменена следующим образом:

1. удалить первый блок кода if:

   if (num == 0)
   {
      if (count[num] <= 1)
         System.out.println (numList[num] + " occurs " + count[num] + " time");
   
      if (count[num] > 1)
         System.out.println (numList[num] + " occurs " + count[num] + " times");
   } 
   

2. Измените второе условие if на:

   if ((num + 1) == MAX_NUM || numList[num] != numList[num + 1]) {
       ......
   }
   

После этого ваш код должен работать хорошо, как и ожидалось.

Кстати, вам действительно не нужно делать это так сложно. Просто попробуйте HashMap :)

Попробуйте ХэшМап. Для этого типа задач хэши очень эффективны и быстры.

Я пишу эту функцию, которая берет массив и возвращает HashMap, ключом которой является число, а значением является появление этого числа.

public static HashMap<Integer, Integer> getRepetitions(int[] testCases) {    
    HashMap<Integer, Integer> numberAppearance = new HashMap<Integer, Integer>();

    for(int n: testCases) {
        if(numberAppearance.containsKey(n)) {
            int counter = numberAppearance.get(n);
            counter = counter+1;
            numberAppearance.put(n, counter);
        } else {
            numberAppearance.put(n, 1);
        }
    }
    return numberAppearance;
}

Теперь выполните итерацию по хэш-карте и напечатайте появление таких чисел:

HashMap<Integer, Integer> table = getRepetitions(testCases);

for (int key: table.keySet()) {
        System.out.println(key + " occur " + table.get(key) + " times");
}

Выход:

Я бы использовал Bag, коллекцию, которая подсчитывает, сколько раз элемент появляется в коллекции. Apache Commons имеет его реализацию. Вот их интерфейс, а вот реализация отсортированного дерева.

Вы бы сделали что-то вроде этого:

Bag<Integer> bag = new TreeBag<Integer>();
for (int i = 0; i < numList.length; i++) {
    bag.add(numList[i]);
}
for (int uniqueNumber: bag.uniqueSet()) {
    System.out.println("Number " + uniqueNumber + " counted " + bag.getCount(uniqueNumber) + " times");
}

В приведенном выше примере берутся элементы из вашего массива numList и добавляются к Bag для целей генерации счетчиков, но по умолчанию вам даже не нужен массив. Просто добавьте элементы в Bag напрямую. Что-то типа:

// Make your bag.
Bag<Integer> bag = new TreeBag<Integer>();

...

// Populate your bag.
for (num = 0; num < MAX_NUM; num++) {
    bag.add(scan.nextInt());
}

...

// Print the counts for each unique item in your bag.
for (int uniqueNumber: bag.uniqueSet()) {
    System.out.println("Number " + uniqueNumber + " counted " + bag.getCount(uniqueNumber) + " times");
}

Вы можете начать с инициализации массива значений между MIN и MAX. Затем вы можете добавить к каждому элементу массива, когда это значение встречается ¹. Что-то типа,

Scanner scan = new Scanner(System.in);
final int MAX_NUM = 10;
final int MAX_VALUE = 100;
final int MIN_VALUE = 1;
final int SIZE = MAX_VALUE - MIN_VALUE;
int[] numList = new int[SIZE];
System.out.printf("Enter %d integers between %d and %d:%n", 
        MAX_NUM, MIN_VALUE, MAX_VALUE);
for (int i = 0; i < MAX_NUM; i++) {
  System.out.printf("Please enter number %d: ", i + 1);
  System.out.flush();
  if (!scan.hasNextInt()) {
    System.out.printf("%s is not an int%n", scan.nextLine());
    i--;
    continue;
  }
  int v = scan.nextInt();
  if (v < MIN_VALUE || v > MAX_VALUE) {
    System.out.printf("%d is not between %d and %d%n", 
            v, MIN_VALUE, MAX_VALUE);
    continue;
  }
  numList[v - MIN_VALUE]++;
}
boolean first = true;
for (int i = 0; i < SIZE; i++) {
  if (numList[i] > 0) {
    if (!first) {
      System.out.print(", ");
    } else {
      first = false;
    }
    if (numList[i] > 1) {
      System.out.printf("%d occurs %d times", 
              i + MIN_VALUE, numList[i]);
    } else {
      System.out.printf("%d occurs once", i + MIN_VALUE);
    }
  }
}
System.out.println();

^{1_{См. также сортировка по основанию сортировка подсчетом.}}

Я думаю, что вы можете значительно упростить свой код, если будете использовать этот подход. Вам все еще нужно изменить, чтобы включить MAX_NUM и MAX_VALUE.

public static void main(String[] args) {

    Integer[] array = {1,2,0,3,4,5,6,6,7,8};
    Stack stack = new Stack();

    Arrays.sort(array, Collections.reverseOrder());

    for(int i : array){
        stack.push(i);
    }

    int currentNumber = Integer.parseInt(stack.pop().toString()) , count = 1;

    try {
        while (stack.size() >= 0) {
            if (currentNumber != Integer.parseInt(stack.peek().toString())) {
                System.out.printf("%d occurs %d times, ", currentNumber, count);
                currentNumber = Integer.parseInt(stack.pop().toString());
                count = 1;
            } else {
                currentNumber = Integer.parseInt(stack.pop().toString());
                count++;
            }
        }
    } catch (EmptyStackException e) {
         System.out.printf("%d occurs %d times.", currentNumber, count);
    }
}