Java 在数组中查找重复元素？

我看到一个采访问题如下：

for(int i=0;i<n;i++){
{  
    dup = false;
    for(j=0;j<n;j++){
        if(i!=j && a[i]= a[j]){
            dup = true;
        }

       if(dup == true)
          return a[i]
     }
}

数组中有一个数字重复。请找到它

简单的解决方案如下：

for(int i=0;i<n;i++){
{  
    dup = false;
    for(j=0;j<n;j++){
        if(i!=j && a[i]= a[j]){
            dup = true;
        }

       if(dup == true)
          return a[i]
     }
}

---

for（int i=0；i对数组排序（可以在第一个O（n Log n）中完成）然后，只需对相邻元素进行比较。或者，只要将数组放入哈希表中，并在找到第一个具有exsting项的键时停止。参考
java.util.TreeSet
，它是在底层实现的红黑树，它是O（n*log（n））（当前形式的问题有点让人困惑——我的答案是假设问题是关于在数组中找到两个和给定值之和的数字）

由于给定的数组是未排序的，因此我假设不允许我们对数组进行排序（即数组的给定顺序不能更改）

IMHO最简单的解决方案是迭代每个数字
x
，并检查
I-x
是否出现在数组中的任何位置。这基本上就是O（n^2）解决方案所做的

通过使用某种快速集合数据结构加快搜索速度，这可以归结为O（n）或O（nlogn）。基本上，当我们在数组上迭代时，我们会查询集合中是否出现
I-x

代码（Python）：

解决方案的复杂性取决于所使用的
集合
数据结构的插入/查找复杂性。基于哈希表的实现具有O（1）复杂性，因此它为您提供了O（n）算法，而基于树的
集合
则产生了O（nlogn）算法

编辑：

 Python的<>代码>设置>代码>：< C++ >代码> >代码>树> <代码> >代码> HasSET ，java中的行<代码> i-x将转换为<代码>。包含（i-x）<代码>在java和<代码>中。C++中找到（i-x）＝参见。“在数组中查找重复元素？”
从0到
for (int i=0; i<n-1; i++) 
{
    for (j=i+1; j<n; j++)
    {
         if (a[i] == a[j])
         {
            return i;
         }
    }
}
return -1; 

for（int i=0；i用实际代码（Java）编写前面的答案）：

O（n日志n）时间：

Arrays.sort（arr）；
对于（int i=1；i

O（n）时间：

Set Set=newhashset（）；
对于（int i=0；i
我建议使用哈希映射（假设没有冲突）来解决它

 private boolean hasDuplicate(int[] arr) {
        Map<Integer, Boolean> map = new HashMap();
        // find the duplicate element from an array using map
        for (int i = 0; i < arr.length; i++) {
            if(map.containsKey(arr[i])) {
                return true;
            } else {
                map.put(arr[i], true);
            }
        }
        return false;
    }

private boolean hasdeplicate（int[]arr）{
Map Map=newhashmap（）；
//使用map从数组中查找重复元素
对于（int i=0；i

时间复杂度：O（n）

空间复杂度：O（n）

另一种方法是排序和比较，但排序会增加额外的开销。
通过使用集合，我们可以查看下面的代码片段-

Set<String> set = new HashSet<String>();
    for (String arrayElement : arr) {
        if (!set.add(arrayElement)) {
            System.out.println("Duplicate Element is : " + arrayElement);
        }
    }

Set Set=newhashset（）；
for（字符串数组元素：arr）{
如果（！set.add（arrayElement））{
System.out.println（“重复元素为：“+arrayElement”）；
}
}
找到O（n）复杂度解决方案，如下所示-

int ar[]={0,1,2,3,0,2,3,1,0,2};
    Set  <Integer>mySet=new HashSet<>();
    for(int n:ar){
        if(!mySet.add(n)){
            System.out.println(" "+n);
        }
    }

intar[]={0,1,2,3,0,2,3,1,0,2}；
Set mySet=newhashset（）；
for（int n:ar）{
如果（！mySet.add（n））{
系统输出打印项次（“+n”）；
}
}

以及另一个空间复杂度较低的进程O（N）和可能的O（N logn）--

public-void-duplicateElementSolution（int-ar[]）{
数组。排序（ar）；
对于（int i＝0；你是用C++语言还是java编程？如果你的问题是语言不可知的，删除语言特定的标签。我不理解它，我对Python不太熟悉。U只是把项添加到SET，我们怎么能找到这个代码中的和= i？@ MyTrut:正如我在代码前面的解释中所说的，如果A+B= x，我们有B= X-A，所以我们只检查X。-a位于以前遇到的一组数字中（使用seen
中的表达式
I=item）。该问题已被编辑，偏离了此假设，因此删除此答案可能会更好。基于哈希表的数据结构的最坏情况复杂度可能为O（n^2）如果存在冲突。由于红黑树是自平衡树，因此基于树的数据结构的最坏情况复杂性为O（nlogn）。使该
Set=new HashSet（arr.length）；
（如果接近开始的重复概率很低-如果很高，最好使用
Set
的树实现）.使用foreach循环。只需添加元素并返回if
！Set.add（arr[i]）
。
Set<String> set = new HashSet<String>();
    for (String arrayElement : arr) {
        if (!set.add(arrayElement)) {
            System.out.println("Duplicate Element is : " + arrayElement);
        }
    }

int ar[]={0,1,2,3,0,2,3,1,0,2};
    Set  <Integer>mySet=new HashSet<>();
    for(int n:ar){
        if(!mySet.add(n)){
            System.out.println(" "+n);
        }
    }

    public void duplicateElementSolution(int ar[]){
     Arrays.sort(ar);

    for(int i=0;i<(ar.length-1);i++){
        if(ar[i]==ar[i+1]){
            System.out.println(" "+ar[i]);
        }
    }
  }