Question

我有两个整数数组，一个原始数组和一个修改过的原始数组。可以在原件中添加或删除元素以将其转换为修改后的元素。我的问题是，在修改后，我需要找出哪些元素是新的，哪些元素是相同的，哪些元素不存在于原始数组中。

鉴于数据：

arr1 = 3,2,1      //Original array
arr2 = 1,4,5      //Modified array by adding and/or removing elements

我需要类似的东西：

same = 1
removed = 2,3
added = 4,5

显然，我可以编写几个嵌套的for循环并找到它，但这样效率太低了。我想知道是否有更好或更有效的方法来做它.. 我正在使用Java。 This page解决类似的问题，但不确定我是否可以用它来解决我的问题。

任何帮助都将不胜感激。

Answer 1

如果内存不是约束，我建议使用Set进行这些操作。找到您需要的东西只需要在两个Set对象上调用适当的方法。当然，这假设你的元素中有独特的元素，如果没有，你只对报告内容时的独特元素感兴趣。例如，

public static void testSet() {
    final Set<Integer> first = new HashSet<Integer>(Arrays.asList(1, 2, 3));
    final Set<Integer> second = new HashSet<Integer>(Arrays.asList(1, 4, 5));

    Set<Integer> result = new HashSet<Integer>(first);
    result.retainAll(second);
    System.out.println("Similar: " + result);

    result = new HashSet<Integer>(first);
    result.removeAll(second);
    System.out.println("Removed: " + result);

    result = new HashSet<Integer>(second);
    result.removeAll(first);
    System.out.println("Newly added: " + result);
}
/*
OUTPUT:

Similar: [1]
Removed: [2, 3]
Newly added: [4, 5]
*/

Answer 2

你可以遍历每个数组一次，显然使用一个删除保存迭代，就像从数组后面循环一样。

int[] same
for (int i = arr1.length; i >= 0; i--)
{
    if(arr2.contains(i))
        same.add(i)
        arr1.remove(i)
}
for (int i = arr2.length; i >= 0; i--)
{
    if(same.contains(i))
        arr2.remove(i)
}

然后arr1将被删除，arr2将被添加，same将是相同的。

Answer 3

如果没有重复项，并且最大整数受到约束，并且成员中等密度（例如，1％密度或更高），请将它们设置为BitSet。两个集合的“和”是“相同的”，A.andNot（B）只是A中的那个，而B.andNot（A）只是B中的那些。如果整数中等密度，则速度非常快。

如果整数是稀疏的，则对每个数组进行排序并将它们串联起来。

Answer 4

您正在尝试计算两个数组之间的Levenshtein distance。

有一个简单的动态编程解决方案来计算这个（取自维基百科）：

int LevenshteinDistance(char s[1..m], char t[1..n])
{
  // for all i and j, d[i,j] will hold the Levenshtein distance between
  // the first i characters of s and the first j characters of t;
  // note that d has (m+1)x(n+1) values
  declare int d[0..m, 0..n]

  for i from 0 to m
    d[i, 0] := i // the distance of any first string to an empty second string
  for j from 0 to n
    d[0, j] := j // the distance of any second string to an empty first string

  for j from 1 to n
  {
    for i from 1 to m
    {
      if s[i] = t[j] then  
        d[i, j] := d[i-1, j-1]       // no operation required
      else
        d[i, j] := minimum
                   (
                     d[i-1, j] + 1,  // a deletion
                     d[i, j-1] + 1,  // an insertion
                     d[i-1, j-1] + 1 // a substitution
                   )
    }
  }

  return d[m,n]
}

您可以轻松更改此代码，以告诉您各个操作的内容。

在Java中比较数组

4 个答案: