快速查找数组中元素的数量

Question

我有一个数组，大小可以达到 10000。它只包含 1/2/3/4。我需要找出数组中有多少个 1、2、3 和 4。最快的方法是什么？我使用的语言是 Java。我的一段代码-

for(int i=0; i<myArray.length;i++){
            int element = myArray[i];
            if(element == 1){
                onesCount++;
            }
            else if(element == 2){
                twosCount++;
            }
            else if(element == 3){
                threesCount++;
            }
            else
                foursCount++;
}

我希望有一个好的解决方案。

Answer 1

int count[5]; //initialize this to 0
for(int i = 0; i<n; i++)
{
count[array[i]]+=1;
}

Answer 2

基本上没有比您的解决方案更好的解决方案了。可以更灵活，但不会更快。一切都必须至少一次通过整个数组。

性能优化的唯一领域是避免执行此操作，例如在数组更新时跟踪计数器。是否值得麻烦（可能不值得）取决于您需要执行此操作的频率、数组有多大以及您还需要用它做什么。

Answer 3

您将拥有用于数组条目的单独计数器。每一个都会在找到一个新的匹配数字时递增，因此您必须至少访问每个索引一次，也就是说您将有一个算法在 O(n) 时间内工作。可以首选 Switch 语句，而不是多个 if-else 语句：

int[] array = new int[10000];
// ... populate array
int[] counters = new int[4];

for (int i = 0; i < array.length; i++)
{
    int temp = array[i];
    switch (temp) {
    case 1:
        counters[0]++;
        break;
    case 2:
        counters[1]++;
        break;
    case 3:
        counters[2]++;
        break;
    case 4:
        counters[3]++;
        break;
    default:
        // to do.
    }
}

Answer 4

如果您使用的是 Java 7，则可以使用 Fork/Join Framework。 复杂度仍然是 O(n)... 但对于大型数组可能会更快

Answer 5

您可以使用一次遍历数组来做到这一点。

您只需拥有一个由四个元素组成的数组，每个元素代表您的一个值 (1/2/3/4)，对于原始数组中的每个元素，您可以在“count”数组中的相应位置增加计数。 这将使它成为 O(n)。

Answer 6

如果您可以改用 Map 或自定义类。如果不能，则必须遍历整个数组。如果您现在没有遇到性能问题，我建议您只进行迭代。

Answer 7

如果 switch 版本（deporter）或 noMAD 的版本不是最好的，试试这个：

for (int i = 0; i < myArray.length; i++) {
    int element = myArray[i];
    if (element > 2) {
        if (element == 4) {
            foursCount++;
        } else 
            threesCount++;
    } else {
        if (element == 2) 
            twosCount++;
        else 
            onesCount++; 
    }
}

它可能会节省少量比较。但这取决于真实数据。如果您对数据很幸运，那么简单的版本可能会更好。

除此之外，对于大数据，使用并行性总是值得一试的。

Answer 8

我认为你不会比这更快：

final int[] counts = new int[5];
final int length = array.length - 1;
for (int i = 0; i < length; i++) {
   counts[array[i]]++;
}

请注意，在 for 循环中，array.length 没有被引用。它被放入一个本地 final int 中，这样可以避免在每次迭代中取消引用 array.length。

我对 this 与 this 使用 switch..case 语句且仅使用本地堆栈变量的方法进行了基准测试：

    int count1 = 0;
    int count2 = 0;
    int count3 = 0;
    int count4 = 0;

    for (int i = array.length - 1; i >= 0; i--) {
        switch (array[i]) {
        case 1:
            count1++;
            break;
        case 2:
            count2++;
            break;
        case 3:
            count3++;
            break;
        case 4:
            count4++;
            break;
        }
    }

结果是第一种方法耗时 17300 纳秒，switch..case 方法耗时 79800 纳秒。 [更新：忘记将纳秒除以 10。我将每种方法运行了 10 次。]

注意：我确实在基准测试之前先警告了 VM。