blocks|key|2721739|text|我会这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2721740|创建
HashMap+count+=新的HashMap()；|ordered-list-item|2721741|迭代数组，将数组值作为键存储，并将值的计数作为值存储在hashmap中。|2721742|第二次迭代数组，如果计数到键为1，则从数组中移除值。|2721743|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|M|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|N|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|O|8|@]|9|@]|A|$]]]|J|$]]

I would do it like this: 

<ol>
<li>create a 

HashMap count =new HashMap();</li>
<li>iterate your array store the array-value as key and the count of the value as value in the hashmap</li>
<li>iterate the array a second time and remove value from the array if count to the key is one.</li>
</ol>

blocks|key|242539|text|没有什么能让数组消失。只需对数组进行迭代，检查映射中的值是否大于一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|242540|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

There's nothing making the array vanish. Just iterate over the array, checking whether the value in the map is greater than one.

blocks|key|242553|text|因此，一种简单的方法是首先计数每个元素的数量(可以在O(n)中完成)，在计数器上迭代，并将count+=1的所有元素放在一个集合中(也可以在O(n)中)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|242554|现在，运行原始列表，并打印所有不在您的集合中的元素(也是O(n))。因此，解决方案将在O(n)时间和空间中运行。|242555|下面是python中的2行解决方案：|242556|from+collections+import+Counter
arr+=+[9,1,2,4,1,2,2]

unique+=+{k+for+k,+v+in+Counter(arr).iteritems()+if+v+==+1}
print+[i+for+i+in+arr+if+i+not+in+unique]|code-block|syntax|javascript|242557|entityMap^0|Q|4|1Y|4|0|S|4|17|4|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|11|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

So an easy way to do this is to first count the number of each element (can be done in <code>O(n)</code>), iterate over the counter and put all elements with count = 1 in a set (also in <code>O(n)</code>).

Now run through the original list and print all elements that are not in your set (also <code>O(n)</code>). So the solution will run in <code>O(n)</code> time and space.

And here is 2 line solution in python:

<pre><code>from collections import Counter
arr = [9,1,2,4,1,2,2]

unique = {k for k, v in Counter(arr).iteritems() if v == 1}
print [i for i in arr if i not in unique]
</code></pre>

blocks|key|2811244|text|只需计数元素，并检查当前元素的总数是否大于1。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2811245|代码示例(C%2B%2B11)：|2811246|#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)+{
++++%2B%2Bcounter[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;
}|code-block|syntax|javascript|2811247|输出：|2811248|Unique:
9+4+
Not+unique:
1+2+1+2+2+|2811249|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Just count elements and check if the total count of current element is greater than one.

Code example (C++11):

<pre><code>#include &lt;iostream&gt;
#include &lt;unordered_map&gt;
#include &lt;vector&gt;

int main() {
 std::vector&lt;int&gt; to_split = {9, 1, 2, 4, 1, 2, 2};

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

 std::cout &lt;&lt; "Unique: " &lt;&lt; std::endl;
 for (int elem : unique) {
 std::cout &lt;&lt; elem &lt;&lt; " ";
 }
 std::cout &lt;&lt; std::endl;
 std::cout &lt;&lt; "Not unique:" &lt;&lt; std::endl;
 for (int elem : not_unique) {
 std::cout &lt;&lt; elem &lt;&lt; " ";
 }
 std::cout &lt;&lt; std::endl;
 return 0;
}
</code></pre>

Output:

<pre><code>Unique:
9 4 
Not unique:
1 2 1 2 2 
</code></pre>

blocks|key|242565|text|只是头脑风暴一点点，但我不得不考虑如何使一个不稳定的排序算法可以稳定:装饰，排序，取消装饰。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|242566|给定输入列表，迭代它，将项目的位置添加到地图中的列表中。|242567|for+(i+=+0;+i+<+length;+i%2B%2B)+{
++++value+=+list[i]
++++map[value].append(i)
}|code-block|syntax|javascript|242568|然后，使用count+1删除所有项，并重构列表(您可以这样做，因为地图中有索引)。|242569|再考虑一下:为什么不直接做一个循环计数，然后再执行另一个循环来构造过滤的列表呢？我认为O(n)可能甚至有更好的性能。(1次迭代进行计数，1次迭代以重新构造新列表)|offset|length|style|CODE|242570|entityMap^0|0|0|0|0|17|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Just brainstorming a bit, but I somehow have to think about how an unstable sorting algorithm can be made stable: decorate, sort, undecorate.

Given your input list, you iterate over it, adding the position of the item to a list in a map.

<pre><code>for (i = 0; i &lt; length; i++) {
 value = list[i]
 map[value].append(i)
}
</code></pre>

Then, remove all items with count 1, and reconstruct the list (which you can do, because you have the indices in the map).

Thinking about it further: why not just do 1 loop counting, and then another loop to construct the filtered list? Probably even has better performance, I think <code>O(n)</code>. (1 iteration to do the counts, 1 iteration to re-construct the new list)

blocks|key|2811320|text|类似于fedekau的方法，但不算在内：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2811321|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));|code-block|syntax|javascript|2811322|(或在填写seenBefore时尽量避免“找到我两次”)|style|CODE|2811323|for+(int+i+:+numbers)
++++seenBefore.compute(i,+(k,+seen)+->+null+!=+seen);|2811324|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/34935696/3789665^0|3|7|0|0|0|5|A|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@$A|12|B|13|K|L]]|9|@]|C|$]]|$1|M|3|N|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|O|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Similar to <a href="https://stackoverflow.com/a/34935696/3789665">fedekau</a>'s approach, but not counting:

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

(or try to avoid "finding i twice" in filling <code>seenBefore</code>:

<pre><code>for (int i : numbers)
 seenBefore.compute(i, (k, seen) -&gt; null != seen);
</code></pre>

There is one question which is bugging me, and somehow, I cannot figure out what to do with it. Suppose an array <code>{9,1,2,4,1,2,2}</code> is given. The unique elements in the array are <code>9</code> and <code>4</code>. The output array should be <code>{1,2,1,2,2}</code> . 
My idea to preserve the order and find duplicates is to use a LinkedHashMap which will have the entries and the count of occurrence of the entries.

The problem is maintaining the order of the elements. Once I put the entries in the hashMap, the order will vanish.

Algorithm to remove unique elements from array and print elements in original order

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有一个问题困扰着我，不知何故，我想不出该怎么办。假设给出了一个数组{9,1,2,4,1,2,2}。数组中的唯一元素是9和4。输出数组应该是{1,2,1,2,2}。我保留顺序和查找重复项的想法是使用一个LinkedHashMap，它将包含条目和条目出现的计数。问题是维持元素的顺序。一旦我把条目放在hashMap中，命令就会消失。

问从数组中删除唯一元素并按原始顺序打印元素的算法
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从数组中删除唯一元素并按原始顺序打印元素的算法EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问从数组中删除唯一元素并按原始顺序打印元素的算法
EN