Question

的后续行动

我有

Set<Set<Node>> NestedSet = new HashSet<Set<Node>>();

[[Node[0], Node[1], Node[2]], [Node[0], Node[2], Node[6]], [Node[3], Node[4], Node[5]]  [Node[2], Node[6], Node[7]] ]

当有两个共同的元素时，我想合并集合。例如，0,1,2和0,2,6有两个共同的元素，因此将它们合并为[0,1,2,6]。

再次[0,1,2,6]和[2,6,7]有2和6共同。所以将它们合并并获得[0,1,2,6,7]。

最终输出应为：

[  [Node[0], Node[1], Node[2], Node[6], Node[7]], [Node[3], Node[4], Node[5]] ]

我试过这样：

         for (Set<Node> s1 : NestedSet ) {
                        Optional<Set<Node>> findFirst = result.stream().filter(p -> { HashSet<Node> temp = new HashSet<>(s1); 
                        temp.retainAll(p); 
                        return temp.size() == 2; }).findFirst(); 

                        if (findFirst.isPresent()){

                            findFirst.get().addAll(s1); 
                        }
                        else {
                            result.add(s1);
                        }    

                    }

但我得到的结果是：

[[Node[0], Node[1], Node[2], Node[6], Node[7]], [Node[3], Node[4], Node[5]], [Node[0], Node[2], Node[6], Node[7]]]

有什么想法吗？有没有办法获得所需的输出？

Answer 1

一些注意事项：

每次应用合并时，都必须重新启动该过程并迭代修改后的集合。因此，输入集的迭代顺序很重要，如果您希望您的代码是确定性的，您可能希望使用为其迭代顺序提供保证的集合（例如，使用LinkedHashSet（不是HashSet ）或List。
您当前的代码有副作用，因为它在合并时修改了提供的集合。总的来说，我认为尽可能避免产生副作用。

以下代码可以满足您的需求：

static <T> List<Set<T>> mergeSets(Collection<? extends Set<T>> unmergedSets) {
  final List<Set<T>> mergedSets = new ArrayList<>(unmergedSets);

  List<Integer> mergeCandidate = Collections.emptyList();
  do {
    mergeCandidate = findMergeCandidate(mergedSets);

    // apply the merge
    if (!mergeCandidate.isEmpty()) {
      // gather the sets to merge
      final Set<T> mergedSet = Sets.union(
          mergedSets.get(mergeCandidate.get(0)),
          mergedSets.get(mergeCandidate.get(1)));

      // removes both sets using their index, starts with the highest index
      mergedSets.remove(mergeCandidate.get(0).intValue());
      mergedSets.remove(mergeCandidate.get(1).intValue());

      // add the mergedSet
      mergedSets.add(mergedSet);
    }
  } while (!mergeCandidate.isEmpty());

  return mergedSets;
}

// O(n^2/2)
static <T> List<Integer> findMergeCandidate(List<Set<T>> sets) {
  for (int i = 0; i < sets.size(); i++) {
    for (int j = i + 1; j < sets.size(); j++) {
      if (Sets.intersection(sets.get(i), sets.get(j)).size() == 2) {
        return Arrays.asList(j, i);
      }
    }
  }
  return Collections.emptyList();
}

为了测试这个方法，我创建了两个辅助方法：

static Set<Integer> set(int... ints) {
  return new LinkedHashSet<>(Ints.asList(ints));
}

@SafeVarargs
static <T> Set<Set<T>> sets(Set<T>... sets) {
  return new LinkedHashSet<>(Arrays.asList(sets));
}

这些辅助方法允许编写非常易读的测试，例如（使用问题中的数字）：

public static void main(String[] args) {
    // prints [[2, 6, 7, 0, 1]]
    System.out.println(mergeSets(sets(set(0, 1, 2, 6), set(2, 6, 7))));
    // prints [[3, 4, 5], [0, 2, 6, 1, 7]]
    System.out.println(
      mergeSets(sets(set(0, 1, 2), set(0, 2, 6), set(3, 4, 5), set(2, 6, 7))));
}

Answer 2

我不确定你为什么会得到这个结果，但我确实看到了这个代码的另一个问题：它依赖于顺序。例如，即使代码按预期工作，首先将[Node[0], Node[1], Node[2]]与[Node[0], Node[2], Node[6]]或[Node[2], Node[6], Node[7]]进行比较也很重要。但是Set没有定义的顺序，因此结果要么是非确定性的，要么取决于实现，具体取决于你如何看待它。

如果您真的想要确定性的依赖于顺序的操作，那么您应该使用List<Set<Node>>，而不是Set<Set<Node>>。

当两个元素共同时，合并设置

2 个答案: