检查两个数组的值是不是相等且顺序相同[关闭]

Posted 2023-03-28

【中文标题】检查两个数组的值是不是相等且顺序相同[关闭]

【英文标题】：Check if two array's values are equal and in same order [closed]检查两个数组的值是否相等且顺序相同[关闭]

【发布时间】：2017-04-25 16:51:35

【问题描述】：

我被困在一个特定的逻辑上。我有两个数组，我需要检查这两个数组的值是否相等且顺序相同。也允许循环。比方说：

array1 = 4, 3, 2, 1
array2 = 1, 4, 3, 2 -- true. 

array1 = 4, 3, 2, 1
array2 = 2, 1, 4, 3 -- true. 

数组值允许重复。我无法对数组进行排序，因为允许重复，它会弄乱数组顺序。

【问题讨论】：

迭代数组并检查值

Java 还是 Lua？已经做出选择了。

所以你需要看看这些值的顺序是否相同，但是它们可以从数组中的任何点开始并环绕？

@DanArmstrong。没错。

为什么还要标记 Lua？

【参考方案1】：

您可以编写嵌套循环，但让我们换个思路。如果我们将第二个数组附加到自身，我们可以对第二个数组执行第一个数组的“indexOf”操作。这里有一些未经测试的代码展示了这个想法：

public static boolean arraysMatch(int[] array1, int[] array2) 
    int[] combined = new int[array2.length * 2];
    System.arraycopy(array2, 0, combined, 0, array2.length);
    System.arraycopy(array2, 0, combined, array2.length, array2.length);
    return Collections.indexOfSubList(Arrays.asList(combined), Arrays.asList(array1)) != -1;

或者更以列表为中心的方法：

public static boolean arraysMatch(int[] array1, int[] array2) 
    List<Integer> combined = new ArrayList<>(array2.length * 2);
    List<Integer> array2List = Arrays.asList(array2);
    combined.addAll(array2List);
    combined.addAll(array2List);
    return Collections.indexOfSubList(combined, Arrays.asList(array1)) != -1;

您可以进行循环而不是复制数据，但这是程序员时间与 CPU 时间的问题。

编辑：我知道答案被接受，但它仍然不是很完整。如果允许使用 Apache Commons Lang：https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/apache/commons/lang/ArrayUtils.html

public static boolean arraysMatch(int[] array1, int[] array2) 
    return Collections.indexOfSubList(
        Arrays.asList(ArrayUtils.toObject(ArrayUtils.addAll(array2, array2))),
        Arrays.asList(ArrayUtils.toObject(array1))
    ) != -1;

【讨论】：

创意；代码清晰度和性能之间的良好平衡。至少在 Java 8 中，Arrays.asList() 不接受 int 数组。

遗憾的是，看起来可能需要手动填充 List，因为 Java 似乎没有任何直接的数组操作，我们需要为 indexOfSubList 使用 Collections 类。

如果允许 O.P. 使用 Commons Lang：commons.apache.org/proper/commons-lang ArrayUtils.toObject 可以弥补差距：commons.apache.org/proper/commons-lang/javadocs/api-2.6/org/…

最后一点：我没有检查数组长度，这可能需要根据要求进行。想要确保长度匹配。这匹死马被打得很好。签字。

【参考方案2】：

试试这个：

代码：

import java.util.ArrayList;
import java.util.Arrays;

public class ArrayComparison 

    //  Create arrays
    private static int[] array1 = new int[] 2,3,4,7,1;
    private static int[] array2 = new int[] 2,3,4,7,1;
    private static int[] array3 = new int[] 1,7,4,2,3;
    private static int[] array4 = new int[] 1,2,3,4,5,6,7,8,9;
    private static int[] array5 = new int[] 2,3,4,5,1;

    public static void main(String args[])
        System.out.println(compareArrays(array1, array2));  // True
        System.out.println(compareArrays(array1, array3));  // True
        System.out.println(compareArrays(array1, array4));  // False
        System.out.println(compareArrays(array1, array5));  // False
    

    /**
     * Compares if a1 is equal than a2, no matter the order
     * @param a1 Array 1
     * @param a2 Array 2
     * @return True if a1 == a2, false if a1 != a2. no matter the order
     */
    private static boolean compareArrays(int[] a1, int[] a2)
        boolean areEqual=false;
        //  Clone
        int[] a1Aux = a1.clone();
        int[] a2Aux = a2.clone();
        //  Sort
        Arrays.sort(a1Aux);
        Arrays.sort(a2Aux);
        //  Compare
        if(a1Aux.length == a2Aux.length)
            for(int i=0;i<a1Aux.length;i++)
                if(a1Aux[i] != a2Aux[i])
                    return areEqual;
                
            
            return true;
        
        return areEqual;
    

输出：

true
true
false
false

【讨论】：

我怀疑问题中提到的两个案例是否会返回 true。也许 OP 将能够坚持嵌套循环以将这些考虑在内。

@OleV.V.你是对的，代码已编辑；）

【参考方案3】：

这很简单（但效率很低，涉及大量复制）。我坚持使用 ints 的数组（没有列表或其他集合，没有 Integer 对象）。

public static boolean arraysWrappedEqual(int[] array1, int[] array2) 
    if (array1.length != array2.length) 
        return false;
    
    for (int array2startIndex = 0; array2startIndex < array2.length; array2startIndex++) 
        // compare beginning of array1 with end of array2 and vice versa
        int[] array1beginning = Arrays.copyOfRange(array1, 0, array1.length - array2startIndex);
        int[] array1end = Arrays.copyOfRange(array1, array1.length - array2startIndex, array1.length);
        int[] array2beginning = Arrays.copyOfRange(array2, 0, array2startIndex);
        int[] array2end = Arrays.copyOfRange(array2, array2startIndex, array2.length);
        if (Arrays.equals(array1beginning, array2end) && Arrays.equals(array1end, array2beginning)) 
            return true;
        
    
    return false;

对于问题中的两种情况，它都返回 true。