Question

我在下面编写代码来比较具有相同元素但是在diff顺序中的数组。

 Integer arr1[] = {1,4,6,7,2};
 Integer arr2[] = {1,2,7,4,6};

例如，Above数组与相同的元素1,2,4,6,7相同。如果您有更好的代码用于更大的阵列，请分享。

编辑如果从两个数组中获取唯一元素，并且它们看起来相同，那么数组也应该相等。如何在不使用任何集合类的情况下编写代码。例如：arr1 = {1,2,3,1,2,3} arr2 = {3,2,1}方法应该返回true（=两个数组都相同）。

package com.test;

public class ArrayCompare {

public boolean compareArrays(Integer[] arr1, Integer[] arr2){
    if(arr1==null || arr2==null){
        return false;
    }
    if(arr1.length!=arr2.length){
        return false;
    }

    Integer[] sortedArr1=sortArray(arr1);
    Integer[] sortedArr2=sortArray(arr2);

    for(int i=0;i<sortedArr1.length-1;i++){
        if(sortedArr1[i]!=sortedArr2[i]){
            return false;
        }
    }
     return true;
}
public void swapElements(Integer[] arr,int pos){
    int temp=arr[pos];
    arr[pos]=arr[pos+1];
    arr[pos+1]=temp;
}
public Integer[] sortArray(Integer[] arr){
    for(int k=0;k<arr.length;k++){
        for(int i=0;i<arr.length-1;i++){
            if(arr[i]>arr[i+1]){
                swapElements(arr,i);
            }
        }
    }
    return arr;
}


public static void main(String[] args) {
    Integer arr1[] = {1,4,6,7,2};
    Integer arr2[] = {1,2,7,4,6};
    ArrayCompare arrComp=new ArrayCompare();
    System.out.println(arrComp.compareArrays(arr1, arr2));
}

}

Answer 1

你关心重复计数吗？例如，您需要区分{ 1, 1, 2 }和{ 1, 2, 2 }吗？如果没有，请使用HashSet：

public static boolean compareArrays(Integer[] arr1, Integer[] arr2) {
    HashSet<Integer> set1 = new HashSet<Integer>(Arrays.asList(arr1));
    HashSet<Integer> set2 = new HashSet<Integer>(Arrays.asList(arr2));
    return set1.equals(set2);
}

如果您关心重复项，那么您可以使用Guava中的Multiset。

如果你想坚持排序版本，为什么不使用内置的排序算法而不是自己编写？

编辑：如果您乐意修改现有阵列，则甚至不需要创建副本。例如：

public static boolean compareArrays(Integer[] arr1, Integer[] arr2) {
    Arrays.sort(arr1);
    Arrays.sort(arr2);
    return Arrays.equals(arr1, arr2);
}

您还可以对数组长度不同的情况进行优化：

public static boolean compareArrays(Integer[] arr1, Integer[] arr2) {
    // TODO: Null validation...
    if (arr1.length != arr2.length) {
        return false;
    }
    Arrays.sort(arr1);
    Arrays.sort(arr2);
    return Arrays.equals(arr1, arr2);
}

Answer 2

如果没有重复项，可以将数组转换为集合：

new HashSet<Integer>(Arrays.asList(arr1))
    .equals(new HashSet<Integer>(Arrays.asList(arr2)))

否则：

List<Integer> l1 = new ArrayList<Integer>(Arrays.asList(arr1));
List<Integer> l2 = new ArrayList<Integer>(Arrays.asList(arr1));

Collections.sort(l1);
Collections.sort(l2);

l1.equals(l2);

Answer 3

如果知道值的间隔，则可以保存一个整数数组，其大小等于序列的最大元素。然后遍历每个数组，并在与计数器数组中的值对应的位置处将数字增加1。最后，遍历计数器数组并确定所有非0的元素是否为2.在这种情况下，数组是相等的。

int[] counters = new int[MAX];
for(int i = 0; i < length1; i++)
    counters[array1[i]]++;
for(int i = 0; i < length2; i++)
    counters[array2[i]]++;

bool areEqual = true;
for(int i = 0; i < MAX; i++)
    if(counters[i] != 0 && counters[i] != 2) 
    {
        areEqual = false;
        break;
    }

这假设没有重复。如果你有重复项，那么在前两个for循环中添加：

for(int i = 0; i < length1; i++)
    if(counters[array1[i]] == 0)
       counters[array1[i]]++;

这可确保在第一个重复后不考虑任何重复项。

Answer 4

你重新发明轮子来排序数组。

使用

java.util.Arrays.sort(T[] a, Comparator<? super T> c)

还有一些方法可以对基本类型进行排序，例如int。

Answer 5

尝试此函数返回数组： -

public static String[] numSame (String[] list1, String[] list2) 
     {  
          int same = 0;  
          for (int i = 0; i <= list1.length-1; i++) 
          {  
             for(int j = 0; j <= list2.length-1; j++) 
             {  
                if (list1[i].equals(list2[j])) 
                {  
                    same++;  
                    break;  
                }  
             }  
          }  

          String [] array=new String[same];
          int p=0;
          for (int i = 0; i <= list1.length-1; i++) 
          {  
             for(int j = 0; j <= list2.length-1; j++) 
             {  
                if (list1[i].equals(list2[j])) 
                {  
                    array[p]=  list1[i]+"";
                    System.out.println("array[p] => "+array[p]);
                    p++;
                    break;  
                }  
             }  
          } 
          return array;
       }

Answer 6

private static boolean compairArraysOfDifferentSequence(Integer[] arr1, Integer[] arr2){

    if(arr1 == null || arr2 == null){

        return false;
    }
    if(arr1.length != arr2.length)
    {
        return false;
    }
    else{

        Arrays.sort(arr1);
        Arrays.sort(arr2);

        return Arrays.deepEquals(arr1, arr2);
    }

}

比较具有不同顺序的相同元素的数组

6 个答案: