Question

免责声明：这是IS作业，所以请不要只给我代码，我想用尽可能少的实际代码来解释我如何做到这一点。

所以我有两个未排序且长度相等的整数数组，并且可以包含重复值。由于这是家庭作业，有一个奇怪的条件，我不允许使用java.utils中的任何东西或对数组进行排序。

我应该检查两个数组是否包含相同的元素，无论顺序如何。所以比较阵列[5,6,7,5,6,3]和[6,6,7,5,5,3]将返回true，同时比较[7,7 8]和[7,8,8]不会。

我不知道如何做到这一点，我已经搜索了问题，但他们似乎都使用java.utils中的任何一个，或者数组不包含重复项。我已经尝试循环遍历第一个数组中的每个值，并且对于每个值循环通过第二个数组检查该值是否存在，但是它会重复出现。

我会为正确的方向提供任何帮助，建议或提示。谢谢！

Answer 1

如何依次从第一个int数组中取出每个元素，并检查是否在第二个int数组中找到它。为了使这个想法有效，你需要创建一个布尔值数组，它们都被初始化为false，以指示是否使用了第二个int数组中的值。然后，当您从第一个数组中找到每个值时，将布尔数组中的相应元素设置为true。

Answer 2

一种方法是迭代第一个数组，并删除在第二个数组中找到它们时相同的元素。

如果在第二个数组中找不到第一个数组中的元素，则数组不相等。当您从第二个数组中的第一个数组中找到最后一个元素时，数组是相等的。

如果不修改数组，那么您必须首先克隆您更改的数组。

Answer 3

这里的解决方案可能会在较长的阵列上变慢，因为它是O（n²）

// return how often n appears in an array
public static int count(int n, int[] array) { ... }

public static boolean equalarrays(int[] arr1, int[] arr2) {
   for (int i: arr1) {
       if (count(i, arr1) != count(i, arr2)) return false;
   }
   return arr1.length == arr2.length;
}

Answer 4

这是一项有趣的活动，我将在我自己的时间做。我建议让两个ArrayList包含两个数组表的所有值。我这样做是因为你可以使用remove()方法。循环遍历给定的第一个数组的所有元素。那将是你的参考数组。在参考数组的第一次迭代中获取对象。然后检查你的其他阵列包含它。如果它有剂量那么检查失败并且您可以在现场返回false，如果是的话：删除它然后获得参考数组的下一次迭代。

即使你不想要代码，这里它也在一个pastebin中：http://www.pastebin.com/3BEV2CqH 它接受Object[] ... tables参数并使用equals方法进行比较。如果你能像我一样把它拉下来，我相信你的老师会感到惊讶。

Answer 5

一个简单的解决方案是复制两个数组，然后对副本进行排序和比较。如果您使用良好的排序算法，则为O(NlogN)。如果你使用正确的库方法，你可以用大约3行代码编写它。

@ Andy256和@Stochastically的解决方案都应该有效，但它们都是O(N^2)。

Answer 6

1   public static boolean compare(int[] a, int[] b)
2   {
3       if(a.length != b.length) return false;
4
5       aloop:for(int i = 0; i < a.length; ++i)
6       {
7           bloop:for(int j = 0; j < b.length; ++j)
8           {
9               if(a[i] == b[j])
10              {
11                  for(int k = j; k < i; ++k)
12                  {
13                      if(a[k] == b[j])    continue bloop;
14                  }
15
16                  continue aloop;
17              }
18          }
19
20          return false;
21      }
22
23      return true;
24  }

这基本上说：取两个相同大小的数组（3） a和b，迭代通过a （5），通过b （7）进行迭代，将a的元素与b （9）的每个元素进行比较，如果b的任何元素等于a的元素：

如果为true：检查a的此元素是否已经处理迭代a-loop （11）的索引并与已处理的元素进行比较（13）。
- 如果为true：获取b的下一个元素并重复。 （13）
- 如果为false：获取a的下一个元素并重复。 （17）
如果为false：嗯，当b的任何元素都不等于a的元素时返回false （18）

如果我们到达（23）行，b的所有元素都是a的元素。返回true。

编辑：此外，您可以反转aloop和bloop以获得一些额外的性能。（我没有把它放到主代码块中，因为它往往会让人感到困惑。）

bloop:for(int j = 0; j < b.length; ++j)
// could be written as
bloop:for(int j = b.length; (--j) >= 0; )
// which is faster as the comparison and incrementation step are merged into one

Answer 7

一种常见的通用方法是对两个数组进行排序，然后对它们进行比较。对于任何两个阵列，这种方法总是在可预测的时间内成功。我认为没有任何算法的最坏情况时间明显好于排序数组所需的时间。

然而，在许多情况下，拥有一种“通常”比排序数组更快的方法可能会很有用。举一个简单的例子，假设每个整数X计算一个（X *（X + 123456）），并将这些值的总和相加（作为long）如果两个列表包含相同的值，无论如何，他们的总和应该是平等的。列表可能包含不同的值但仍然会产生相同的总和，但在大多数情况下，列表包含不同的值，它们的总和可以被识别为不同，而不必经历排序列表的麻烦。

您可能想要考虑“哈希基数排序”的另一件事。基数排序的工作原理是每次传递将事物分成桶，然后输出第一个桶的内容，然后输出第二个，第三个，第四个，第五个桶的内容。打孔卡过去常常以这种方式进行分类，使用的机器可以检查每张卡上的一列，并根据打孔的内容将每张卡放入十三个桶中的一个。可以使用一次通过2 ^ 32个桶，两次通过65,536个桶，四次通过256个桶等对任意数量的32位整数进行排序。然而，一个基数排序的轻微烦恼就是在各种铲斗通常会大幅倾斜。如果定义一个将输入值映射到例如数字从0到255，这样每个值将分配1/256个输入，然后一个可以在线性时间内将列表“排序”的任务减少到排序256个列表的任务，每个列表的大小为1/256 。请注意，生成的序列不会按常规意义“排序”，但包含相同项目的两个列表将以相同的方式“排序”。

Answer 8

这是一个解决方案。无论如何，这篇文章很老了

public static boolean equality(int[] list,int[] list2)
  {
    boolean result = false;
    int correct = 0;
    if(list.length == list2.length)
    {
      for(int i = 0; i< list.length; i++)
      {
        for(int j = 0; j < list2.length; j++)
        {
          if(list[i] == list2[j])
          {
            correct++;
            if(correct == list.length && correct == list2.length)
            {
              result = true;
            }
          }
        }
      }
    }
    return result;
  }
}

检查两个int数组是否相等 - 无论顺序如何

8 个答案: