Question

无论是否已经计算过，它都会不断重复。您可以看到示例输出。它已经计算出1的出现次数，但是当它再次看到1时，它会再次计算出来！

public class SortingInLinearTime {
    public static int[][] howMany(int[] n){

        // Makes a double array list where the second value is occurrence of the first value.
        int[][] a = new int[n.length][2]; 
        int counter = 0;

        for(int i = 0; i != n.length; i++){
            for(int j = 0; j != n.length; j++) {

                if(n[i] == n[j]){
                    counter++;
                }
            }
            a[i][0] = n[i];
            a[i][1] = counter;
            counter = 0;
        }

        // printer helper function
        for(int i = 0; i != n.length; i++){ 
            System.out.print(a[i][0] + " occurs ");
            System.out.println(a[i][1] + " times");
        }
        return a;
    }

    public static void main(String[] args) {
        int[] testArray = {1, 2, 3, 1, 2, 3, 4};
        System.out.print(howMany(testArray));
    }
}

输出： 1发生2次 2发生2次 3发生2次 1发生2次 2发生2次 3发生2次 4发生1次 [[I @ 15db9742

Answer 1

在i的第一个循环中，您将一次又一次地重新计算相同的值。当i = 0且i = 3时出现1。你曾经在i == 0时计算为1，并在数组n中的i == 3处重新计算。但是，我相信通过将数据结构从int [] []更改为hashmap，可以实现针对您的问题的最佳解决方案。

Answer 2

使用Arrays.asList（）将数组转换为list，然后使用collections api获取计数。

Collections.frequency（Collection c，Object o）

更新了实施

import java.util.AbstractList;
import java.util.Collections;
import java.util.List;

public class SortingInLinearTime {
    public static int[][] howMany( int[] n){

        // Makes a double array list where the second value is occurrence of the first value.
        int[][] a = new int[n.length][2]; 


        for(int i = 0; i < n.length; i++){
            int count = Collections.frequency(asList(n), n[i]);
            a[i][0] = n[i];
            a[i][1] = count;
         }

        // printer helper function
        for(int i = 0; i < n.length; i++){ 
            System.out.print(a[i][0] + " occurs ");
            System.out.println(a[i][1] + " times");
        }
        return a;
    }


    public static List<Integer> asList(final int[] is)
    {
        return new AbstractList<Integer>() {
                public Integer get(int i) { return is[i]; }
                public int size() { return is.length; }
        };
    }


    public static void main(String[] args) {
        int[] testArray = {1, 2, 3, 1, 2, 3, 4};
        System.out.print(howMany(testArray));
    }
}

Answer 3

通过循环数组两次并使用数组来存储结果，你通过这种方式变得更加困难。试试这个：

public class SortingInLinearTime {
    public static Hashtable<Integer, Integer> howMany(int[] n){
        Hashtable<Integer, Integer> toRet = new Hashtable<Integer, Integer>();
        for (int i = 0; i < n.length; i++) {
            if (!toRet .containsKey(n[i])) {
                toRet.put(n[i], 1);
            } else {
                toRet.put(n[i], toRet.get(n[i]) + 1);
            }
        }
        return toRet;
    }

    public static void main(String[] args) {
        int[] testArray = {1, 2, 3, 1, 2, 3, 4};
        Hashtable<Integer, Integer> counts = howMany(testArray);
        Set<Integer> keys = counts.keySet();
        for(Integer key : keys){
            System.out.println(key + " occurs " + counts.get(key) + " times.");
        }
    }
}

这有几个优点。如果你传递一个数字很大的数组，例如{1, 11, 203, 203}，你当前的实现无法处理它，它不会破坏。通过声明具有许多不需要的元素的数组，它不会使用额外的空间。最重要的是，它有效。

确定每个整数在输入（数组）中出现的次数

3 个答案: