Question

我有一个整数数组：int[] numbers = new int[...n]; // n being limitless.

所有数字都在0到100之间。

说numbers[]等于：[52, 67, 32, 43, 32, 21, 12, 5, 0, 3, 2, 0, 0];

我想计算每个数字出现的频率。

我有第二个阵列：int[] occurrences = new int[100];。

我希望能够存储这样的金额：

for(int i = 0; i < numbers.length; i++) {
   // Store amount of 0's in numbers[] to occurrences[0] 
   // Store amount of 1's in numbers[] to occurrences[1]
}

因此occurrences[0]等于3，occurrences[1]等于0等。

有没有有效的方法可以做到这一点，而不必诉诸外部库？感谢。

Answer 1

您可以简单地执行以下操作：

for (int a : numbers) {
    occurrences[a]++;
}

此外，如果您的意思是0到100 包含，则occurrences的大小必须为101（即100需要是最大索引）。

在更新numbers之前，您可能还需要执行“断言”以确保occurrences的每个元素确实在有效范围内。

Answer 2

已更新，将结果放入100阵列。

import  java.util.Iterator;
import  java.util.Map;
import  java.util.Set;
import  java.util.TreeMap;

/**
   <P>{@code java IntOccurancesInArray}</P>
 **/
public class IntOccurancesInArray  {
   public static final void main(String[] igno_red)  {
      int[] ai = new int[]{52, 67, 32, 43, 32, 21, 12, 5, 0, 3, 2, 0, 0};
      Map<Integer,Integer> mpNumWHits = new TreeMap<Integer,Integer>();
      for(int i = 0; i < ai.length; i++)  {
         int iValue = ai[i];
         if(!mpNumWHits.containsKey(iValue))  {
            mpNumWHits.put(iValue, 1);
         }  else  {
            mpNumWHits.put(iValue, (mpNumWHits.get(iValue) + 1));
         }
      }

      Set<Integer> stInts = mpNumWHits.keySet();
      Iterator<Integer> itrInts = stInts.iterator();

      int[] ai100 = new int[100];

      int i = 0;
      while(itrInts.hasNext())  {
         int iValue = itrInts.next();
         int iHits = mpNumWHits.get(iValue);
         System.out.println(iValue + " found " + iHits + " times");
         ai100[iValue] = iHits;
      }

      for(int j = 0; j < ai100.length; j++)  {
         if(ai100[j] > 0)  {
            System.out.println("ai100[" + j + "]=" + ai100[j]);
         }
      }
   }
}

输出：

[C:\java_code\]java IntOccurancesInArray
0 found 3 times
2 found 1 times
3 found 1 times
5 found 1 times
12 found 1 times
21 found 1 times
32 found 2 times
43 found 1 times
52 found 1 times
67 found 1 times
ai100[0]=3
ai100[2]=1
ai100[3]=1
ai100[5]=1
ai100[12]=1
ai100[21]=1
ai100[32]=2
ai100[43]=1
ai100[52]=1
ai100[67]=1

Answer 3

此方法对于了解所有元素的出现非常有用您可以通过使用排序查找新数组的长度并获取最后一个元素的值+ 1

来减少空间

import java.util.Arrays;

    public class ArrayMain {

        public static void main(String[] args) {
            int a[] = {52, 67, 32, 43, 32, 21, 12, 5, 0, 3, 2, 0, 0};
            Arrays.sort(a);
            int len=a[a.length-1]+1;
            int count[]=new int[len];
            for(int n:a){
                count[n]++;
            }
            for(int j=0;j<count.length;j++){
                if(count[j]>=1){
                System.out.println("count:"+j+"---"+count[j]);
                }
            }

        }

    }

时间复杂度：O（n）空间复杂度：O（R）//最后一个元素值+1

注意：如果您在空间方面有极端数字，如1,2和96,99等，则创建新数组可能不太好。对于这种情况，排序和比较下一个元素是更好的方法

Answer 4

import java.util.Scanner;

public class CountNumOccurences {
   public static void main(String[] args){
      Scanner input = new Scanner(System.in);

      int[] frequency = new int[100];


      System.out.println("Enter the first integer: ");
      int number = input.nextInt();

      //Enter up to 100 integers, 0 to terminate
      while (number != 0){
         ++frequency[number];

         //read the next integer
            System.out.print(
                "Enter the next int value (zero to exit): ");
            number = input.nextInt();
      } 
      input.close();

      System.out.println("Value\tFrequency");
      for (int i = 0; i < frequency.length; i++) {
         if (frequency[i] > 0){
            if (frequency[i] > 1)  
               System.out.println(i + " occurs " + frequency[i] + " times");
            else
               System.out.println(i + " occurs " + frequency[i] + " time");
         }
      }
   }
}

计算数组中整数的出现次数

4 个答案: