Question

有一个问题困扰着我，不知何故，我无法弄清楚该如何处理它。假设给出了数组{9,1,2,4,1,2,2}。数组中的唯一元素是9和4。输出数组应为{1,2,1,2,2}。我保留订单和查找重复项的想法是使用LinkedHashMap，它将包含条目和条目的出现次数。

问题是维持元素的顺序。一旦我将条目放入hashMap，订单就会消失。

Answer 1

没有什么能让阵列消失。只需迭代数组，检查地图中的值是否大于1。

Answer 2

这样做的一个简单方法是首先计算每个元素的数量（可以在O(n)中完成），迭代计数器并将所有带有count = 1的元素放在一个集合中（也在{ {1}}）。

现在浏览原始列表并打印所有不在您的集合中的元素（也是O(n)）。因此，解决方案将在O(n)时间和空间中运行。

这是python中的2行解决方案：

O(n)

Answer 3

只计算元素并检查当前元素的总数是否大于1。

代码示例（C ++ 11）：

#include <iostream>
#include <unordered_map>
#include <vector>

int main() {
  std::vector<int> to_split = {9, 1, 2, 4, 1, 2, 2};

  std::vector<int> unique, not_unique;
  std::unordered_map<int, int> counter;
  for (int elem : to_split) {
    ++counter[elem];
  }
  for (int elem : to_split) {
    if (counter[elem] > 1) {
      not_unique.push_back(elem);
    } else {
      unique.push_back(elem);
    }
  }

  std::cout << "Unique: " << std::endl;
  for (int elem : unique) {
    std::cout << elem << " ";
  }
  std::cout << std::endl;
  std::cout << "Not unique:" << std::endl;
  for (int elem : not_unique) {
    std::cout << elem << " ";
  }
  std::cout << std::endl;
  return 0;
}

输出：

Unique:
9 4 
Not unique:
1 2 1 2 2

Answer 4

只是头脑风暴，但我不得不考虑如何使不稳定的排序算法变得稳定：装饰，排序，不合理。

根据您的输入列表，您迭代它，将项目的位置添加到地图中的列表。

for (i = 0; i < length; i++) {
    value = list[i]
    map[value].append(i)
}

然后，删除计数为1的所有项目，并重建列表（您可以这样做，因为您在地图中有索引）。

进一步思考：为什么不进行1次循环计数，然后再进行另一个循环来构建过滤后的列表？可能甚至有更好的表现，我认为O(n)。（1次迭代进行计数，1次迭代重新构建新列表）

Answer 5

我会这样做：

创建

HashMap count = new HashMap（）;
迭代数组存储数组值作为键，值的计数值作为hashmap中的值
第二次迭代数组，如果对键的计数为1，则从数组中删除值。

Answer 6

与fedekau的方法类似，但不计算：

int[]numbers = {9,1,2,4,1,2,2};
int guessedDistinct = (int)(2 * Math.sqrt(numbers.length));
final Map<Number, Boolean>
    seenBefore = new HashMap<>(guessedDistinct);
for (int i : numbers)
    seenBefore.put(i, seenBefore.containsKey(i));
int[] out = Arrays.stream(numbers)
    .filter(i -> seenBefore.getOrDefault(i, false))
    .toArray();
System.out.println(Arrays.toString(out));

（或尝试避免＆＃34;找到我两次＆＃34;填写seenBefore：

for (int i : numbers)
    seenBefore.compute(i, (k, seen) -> null != seen);

从原始顺序中删除数组和打印元素中的唯一元素的算法

6 个答案: