java - 如何检查两个简单的二维数组是否具有相同的一维数组？ (顺序和重复并不重要)

Question

我的主要目标是返回二维数组 int[ ][ ] 的所有元素 int[ ] 是否存在于另一个二维数组中。

我已经尝试使用Arrays.deepEquals()，但在这种情况下，元素的顺序很重要，但这不是目的。

• 例如，Int[ ][ ] 数组的长度不会超过 15。
• Int[ ][ ] 数组的长度始终相同。
• Int[ ][ ] 数组的顺序并不重要，但 Int[ ] 数组的顺序很重要。
• Int[ ] 数组始终是一对。

预期:

int[][] array1 = {{1, 2}, {2, 2}, {0, 1}, {3,4}} // Main Array

int[][] array2 = {{0, 1}, {2, 2}, {3,4} {1, 2}}} // Expected: true

int[][] array3 = {{6, 3}, {1, 2}, {7,4} {0, 1}}} // Expected: false
  

这是我的解决方案/尝试:

// Check if an int[] array (element) belongs to an int[][] array.

public static boolean inVector(int[][] 2dArray, int[] 1dArray) {

    for (int i = 0; i < 2dArray.length; i++) {
        for (int j = 0; j < 2dArray[i].length; j++) {

            if (1dArray[0] == 2dArray[i][0] && 1dArray[1] == 2dArray[i][1]) {
                return true;
            }
        }
    }

    return false;
}


// Check if all int[] arrays of an int[][] belong to another int[][] array.

// This is not working properly

public boolean allBelongs() {

  boolean belongs = false;

  for (int i = 0; i < array1.length; i++) {
     
     if (inVector(array1, array2()[i])) {
        belongs = true;
     }
     
     else {
        belongs = false;
     }
  }

    return belongs;
}

编辑:我通过反转解决方案的逻辑解决了问题。发布了自己的答案。

Answer 1

您可以使用IntBuffer它可以包装 int[] 数组并提供反射(reflect)数组内容的 equals 和 hashCode 实现。

public static boolean sameSubArrays(int[][] array1, int[][] array2) {
    if(array1 == array2) return true;
    HashSet<IntBuffer> set = new HashSet<>();
    for(int[] a: array1) set.add(IntBuffer.wrap(a));
    for(int[] a: array2) if(!set.contains(IntBuffer.wrap(a))) return false;
    return true;
}

这很简单并且以线性时间运行，因此可以处理大型数组。它具有您的测试用例的预期结果。

int[][] array1 = {{1, 2}, {2, 2}, {0, 1}, {3,4}};
int[][] array2 = {{0, 1}, {2, 2}, {3, 4}, {1, 2}};
System.out.println(sameSubArrays(array1, array2)); // true

但它不考虑重复项。如果必须匹配具有相同内容的子数组的出现次数，则必须扩展解决方案以使用映射来计算出现次数。

public static boolean sameSubArrays(int[][] array1, int[][] array2) {
    if(array1 == array2) return true;
    if(array1.length != array2.length) return false;
    HashMap<IntBuffer, Integer> map = new HashMap<>();
    for(int[] a: array1) map.merge(IntBuffer.wrap(a), 1, Integer::sum);
    for(int[] a: array2)
        if(map.merge(IntBuffer.wrap(a), -1, Integer::sum) < 0) return false;
    return true;
}

由于您的示例没有重复项，因此它仍然具有相同的结果。