Java 在数组中查找未配对的数字_Java_Arrays

Java 在数组中查找未配对的数字

java arrays

Java 在数组中查找未配对的数字,java,arrays,Java,Arrays,我有一个数组，其中除一个元素外，所有元素都重复： int[] a={2,6,6,2,4,1,4}; 如何找到未配对的元素整数？您可以使用映射来记录一个数字出现的次数。毫无疑问，有更好的方法可以做到这一点，但它会奏效的 public static void main( String[] args ) { int[] a = { 2, 6, 6, 2, 4, 1, 4 }; Map<String, Integer> counts = new HashMap<St

我有一个数组，其中除一个元素外，所有元素都重复：

int[] a={2,6,6,2,4,1,4};

如何找到未配对的元素整数？

您可以使用映射来记录一个数字出现的次数。毫无疑问，有更好的方法可以做到这一点，但它会奏效的

public static void main( String[] args ) {
    int[] a = { 2, 6, 6, 2, 4, 1, 4 };

    Map<String, Integer> counts = new HashMap<String,Integer>();

    String key;
    for ( int i : a ) {
        key = String.valueOf( i );
        if ( counts.containsKey( key ) ) {
            int count = counts.get( key );
            counts.put( key, ++count );
        }
        else {
            counts.put( key, 1 );
        }
    }

    for ( Map.Entry<String, Integer> entry : counts.entrySet() ) {
        if ( entry.getValue() < 2 ) {
            System.out.println( entry.getKey() + " does not have a pair" );
        }
    }
}

publicstaticvoidmain（字符串[]args）{
int[]a={2,6,6,2,4,1,4}；
映射计数=新的HashMap（）；
字符串键；
对于（int i:a）{
key=String.valueOf（i）；
if（计数容器（键））{
int count=counts.get（键）；
计数。输入（键，++计数）；
}
否则{
计数。放置（键，1）；
}
}
for（Map.Entry:counts.entrySet（））{
if（entry.getValue（）<2）{
System.out.println（entry.getKey（）+“没有对”）；
}
}
}

您可以采取以下几种方法：

方法1-O（n日志n）：对数组排序。然后，迭代排序数组的元素，每次迭代两个（
```
i=0
```
，
```
i=2
```
，等等）。当
```
a[i]
```
和
```
a[i+1]
```
不相等时，或者当
```
i+1==a.length
```
时，您知道
```
a[i]
```
是不成对的
方法2-O（n2）：迭代元素。对于每个元素
```
a[i]
```
，迭代元素（在嵌套循环中），查看
```
a[i]==a[j]
```
在
```
i！=j
```
。如果不是，则
```
a[i]
```
是不成对的
方法3-O（m），其中m是最大和最小元素之间的差值（注意m是Ω（n））：迭代元素，找到最大和最小值
```
MIN
```
和
```
MAX
```
。创建一个
```
int[]b=newint[MAX-MIN+1]
```
。再次迭代元素，为每个元素增加
```
b[a[i]-MIN]
```
。然后迭代
```
b
```
；当您找到
```
b[j]==1
```
时，
```
j
```
是不成对的

注意：您使用术语“元素整数”，但这不是真正的术语。以上假设您指的是“整数值元素”。如果您实际上指的是“元素索引”，那么在不进行修改的情况下只能使用方法2。方法3需要一点调整，方法1需要大量调整。（当然，一旦找到只出现一次的值，就可以在数组上再迭代一次，以找到该值的索引—前提是仍然保留原始数组顺序。）

编辑后添加：我不知道以前怎么会错过这一点-我想我不习惯在编写Java时考虑按位操作-但最好的解决方案实际上是：

方法4-O（n）：计算数组所有元素的按位异或，
```
^
```
。这是未配对的元素。你看，异或是交换的和结合的，所以
```
2^6^6^2^4^1^4
```
与
```
1^（2^2）^（4^4）^（6^6）
```
是一样的；而且
```
x^x
```
始终是
```
0
```
，因此这两个对总是相互抵消。你可以写：
```
int result = 0;
for(int i : a)
    result ^= i;
```
计算未配对的元素。（要获得未配对元素的索引，您需要再次迭代数组，查找
```
结果
```
）

Codibility example中列出了一个示例，我在那里测试了这段代码，发现一些性能也很差的测试用例的正确性

尝试将convert转换为arraylist（asList（）），然后迭代元素，将当前和以前的代码进行比较。如果找到任何不带对的对象，则抛出布尔值。这个逻辑不正确。在你的问题中发布代码。发布你所做的，如果出现问题，社区将提供帮助。这是我第一次在家庭作业标签下发布。我在一次采访中被问到这个问题。这就是为什么我把它贴在家庭作业下面。我试过了，力不从心，所以在这里问。至于你们是否回答或结束这一问题，他在给我的几分钟时间内想不出这样一个解决办法（你不需要把

int

作为

字符串

，只需要做一个

映射

，就可以了=）对于第一种方法，你可能还需要

O（N）

空间，这取决于排序算法。有人能分享一个我可以学习如何计算复杂性的源代码吗？我的意思是O（n），O（logn）。我不知道他们是什么意思。编辑：有一个-->