有没有更快的方法来比较 Java 中的两个 Int 数组？

Question

我有两个整数数组，每个 大小相同，比如 n（n 是可变的，所以我可以有两个大小为 4 或 5 或 6 等的数组）以及每个数字的值范围可以取的范围是0-9。 示例

Integer[] one = {1,9,3,4} 
Integer[] two = {1,1,9,3}

现在，我想比较数组一和二，这样 1) 我可以获得相同且位于相同位置的元素的数量。 2)我可以得到相同但不在同一位置的数字。

我采取的方法是

对于 (1) 遍历数组 1 并为每个索引检查 one[i] == two[i]。 - 简单。

对于 (2) 遍历两个数组，对于 i != j，查看元素是否相同，如果相同，用 -1 标记它们以避免将来发生冲突。

for(int i =0;i<one.length;i++){
    for(int j=0;j<two.length;j++){
        if(i != j && one[i] != -1 && two[j] !=-1)){
            if(one[i] == two[j]){
                whiteCount++
                one[i] = -1;
                two[j] = -1;
            }
        }
    }
}

问题：现在我想知道是否有更快的方法来做同样的事情？特别是。计算问题的(2)nd 部分。 这是获得Mastermind棋盘游戏黑白钉计算的基本比较方法。 谢谢 沙克蒂

更新 1： 1) Rudi 的建议将 Integer[] 改为 int[]

2) 使用 Dave Challis 的解决方案 性能变化 对于 7776 X 7776 计算

OLD 46950 ms
NEW 42887 ms

Answer 1

虽然这可能不是您想要的，但我们可以通过一个非常简单的更改来显着减少操作数量。

来自

Integer[] one = {1,9,3,4} 
Integer[] two = {1,1,9,3}

到

int[] one = {1,9,3,4} 
int[] two = {1,1,9,3}

这会稍微加快处理速度，但不会优化排序/搜索逻辑本身。我们所做的只是删除自动装箱和自动拆箱操作。但是，如果您在非常大的范围内这样做，那么这可能会产生重大影响。

Answer 2

下面的解决方案是 O(2N)，不使用任何额外的库，也不修改初始数组。

它遍历两个数组一次以获取相同位置的整数计数。在执行此操作时，它会建立第二个数组中每个数字的计数（并存储在counts 数组中）。

然后它再次遍历第一个数组，得到每个数字在第二个数组中的总次数：

final Integer[] one = {1,9,3,4};
final Integer[] two = {1,1,9,3};

int samePositionCount = 0;
int sameNumberCount = 0;

// tracks number of times an int is in the 2nd array
final Integer[] counts = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

for (int i = 0; i < one.length; i++) {
    if (one[i].equals(two[i])) {
        samePositionCount++;
        counts[one[i]] = -1; // mark as seen in same position count
    } else if (counts[two[i]] != -1) {
        counts[two[i]]++;
    }
}

for (int i : one) {
    if (counts[i] > 0) {
        sameNumberCount += counts[i];
        counts[i] = 0; // avoid adding twice
    }
}

System.out.println(samePositionCount + " " + sameNumberCount);

打印：

1 2

Answer 3

要获得相同但在不同位置的数字的数量，您可以这样做。

public static long[] encode(int... nums) {
    long[] ret = new long[nums.length];
    for (int i = 0; i < nums.length; i++) {
        ret[i] = ((long) nums << 32) + i;
    }
    Arrays.sort(ret);
}

// encode both arrays and do a merge sort, skipping matches which have the same index.

这是一个 O(n log N) 操作。

---

您可以将one[i] != -1 移出，以便它可以跳过该值。

int[] one = {1,9,3,4}; // Using int is faster and clearer.
int[] two = {1,1,9,3};

for (int i = 0; i < one.length; i++){
    if (one[i] == -1) continue;
    for (int j = 0; j < two.length; j++){
        if (one[i] == two[j] && i != j && two[j] != -1) {
            whiteCount++
            one[i] = -1;
            two[j] = -1;
        }
    }
}

首先放置one[i] == two[j] 可以提高性能，因为它通常是错误的，因此不需要检查其他内容。

Answer 4

为什么不使用现有的实用方法来比较 aaarays。他们肯定更快。您可以检查“等于”方法的实现并确认。

import java.util.Arrays;

class Test {
public static void main(String[] args) {
    int inarr1[] = {1, 2, 3};
    int inarr2[] = {1, 2, 3};
    Object[] arr1 = {inarr1};
    Object[] arr2 = {inarr2};
    if (Arrays.deepEquals(arr1, arr2))
        System.out.println("Same");
    else
        System.out.println("Not same");
   }

}