Вывести максимальное повторное значение

Question

Я хочу напечатать наиболее повторяемое значение в массиве. Если два значения повторяются максимальное количество раз, выведите наибольшее. Я не знаю, как распечатать наибольшее. Я пробовал это. Он просто печатает наиболее повторяемое значение в массиве.

int[] a= { 3,2,3,2,2};
        int count = 1, tempCount;
  int repeated = a[0];
  int temp = 0;
  for (int i = 0; i < (a.length - 1); i++)
  {
    temp = a[i];
    tempCount = 0;
    for (int j = 1; j < a.length; j++)
    {
      if (temp == a[j])
        tempCount++;
    }
    if (tempCount > count)
    {
     repeated = temp;
      count = tempCount;
    }
  }
  System.out.println(repeated);

Если предположить, что элементы массива имеют значение «3,2,3,3,2,4,5,4,6,4», то он должен напечатать 4. (№ 3 три раза и № 4 три раза. .... Но 4 - это самое большое число, поэтому на выходе получается 4). Теперь, как я могу изменить свой код?

Answer 1

Здесь:

repeated = temp;

Вы нашли «новое» повторное значение, и вы безоговорочно присваиваете .

Вам необходимо различать два случая:

if (tempCount == count && temp > repeated)
{
   // updates for EQUAL count, but only for larger numbers
   repeated = temp;
   count = tempCount;
}
if (tempCount > count)
{
  // updates for larger count, small/large value doesn't matter
  repeated = temp;
  count = tempCount;
}

решит вашу проблему!

Answer 2

измените j в этом коде, чтобы оно равнялось 0

for (int j = 1; j < a.length; j++)

, поскольку оно пропускает первый элемент массива, в результате чего 3 считается только два раза.также эта логика должна помочь, если число, которое больше, имеет равное число

    int[] a= {3,2,3,2,2, 2, 4, 4, 5 ,5};
        int count = 1, tempCount;
        int repeated = a[0];
       int temp = 0;
       for (int i = 0; i < (a.length - 1); i++)
        {
       temp = a[i];
       tempCount = 0;
      for (int j = 0; j < a.length; j++)
    {
      if (temp == a[j])
        tempCount++;
    }
    if (tempCount ==count )
    {
        if(temp>repeated ){

     repeated = temp;
      count = tempCount;
        }
    }
    if (tempCount > count)
    {
     repeated = temp;
      count = tempCount;
    }
  }
    System.out.println(repeated);
    }
}

Редактировать Я знаю, что оно ленивое, но я сохранил его в формате кода постеров.

Answer 3

Вместо многократного повторения массива я бы, вероятно, просто повторил один раз и посчитал бы вхождения.

A Map<Integer, Integer> поможет здесь, особенно если числа могут стать отрицательными или иметь «дыры» (то есть у вас есть что-то вроде [1,2,5,9,1,9,9]). Здесь ключом будет число, а значением будет количество. Пример:

Map<Integer,Integer> counts = new HashMap<>();
for(int n : a ) {
  counts.merge(n, 1, (value,increment) -> value + increment );
}

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

Answer 4

Этот подход был назван overkill в комментарии под вашим вопросом, поскольку кто-то (кроме меня) предложил использовать карту . Я думаю, что это правильный подход из-за использования структуры данных Map. Смотрите комментарии в коде:

public static void main(String[] args) {
    int[] a = { 3, 2, 3, 2, 2 };
    int[] b = { 3, 2, 3, 3, 2, 4, 5, 4, 6, 4 };
    // create a data structure that holds the element and its count
    Map<Integer, Integer> occurrences = new HashMap<Integer, Integer>();
    /*
     * go through the array and store each element found as the key and how often it
     * was found as the value
     */
    for (int n : b) {
        if (occurrences.containsKey(n)) {
            /*
             * if the key is already contained, increment the value (additional occurrence
             * found)
             */
            occurrences.put(n, occurrences.get(n) + 1);
        } else {
            // otherwiese just add the key with value one (first occurrence)
            occurrences.put(n, 1);
        }
    }

    // now you have all the elements with its occurrences, go find the one to be displayed

    // print them once (not necessary for the result)
    occurrences.forEach((key, value) -> System.out.println(key + " : " + value));

    // get the largest number with the largest occurrence count
    int maxValue = 0;
    int maxKey = 0;

    for (int i : occurrences.keySet()) {
        if (occurrences.get(i) > maxValue) {
            // if you find a larger value, set the current key as max key
            maxKey = i;
            maxValue = occurrences.get(i);
        } else if (occurrences.get(i) == maxValue) {
            /*
             * if you find a value equal to the current largest one, compare the keys and
             * set/leave the larger one as max key
             */
            if (i > maxKey) {
                maxKey = i;
            }
        } else {
            // no need for handling a smaller key found
            continue;
        }
    }

    System.out.println("Largest key with largest value is " + maxKey);
}

Answer 5

Вот решение вашей проблемы.Прочитайте комментарии в коде для большего понимания.Ваш код имеет сложность O (n ^ 2).Код ниже имеет сложность O (n) и работает намного быстрее.

 public static void main(String[] args){
    int[] arr = new int[]{3,2,3,3,2,4,5,4,6,4};
    // Assuming A[i] <= 100. Using freq[] to capture the frequency of number
    // freq[] will behave as a Map where index will be the number and freq[index] will be the frequency
    // of that number
    int[] freq = new int[101];

    for(int i=0;i<arr.length;i++){
        int num = arr[i];
        freq[num]++;
    }
    int max = 0;
    int ans = 0;
    for(int i=0;i<freq.length;i++){
        if(freq[i] >= max){
            ans = i;
            max = freq[i];
        }
    }
    System.out.println(ans);
}