当元素不限于某个范围时，在给定数组中查找重复项

给定一个由 n 个整数组成的数组。任务是打印给定数组中的重复项。如果没有重复，则打印 -1。

例子：

Input: {2, 10,10, 100, 2, 10, 11,2,11,2}
Output: 2 10 11

Input: {5, 40, 1, 40, 100000, 1, 5, 1}
Output: 5 40 1

注意：可以按任何顺序打印重复元素。

简单的方法：这个想法是使用嵌套循环，并为每个元素检查元素是否多次出现在数组中。如果存在，则将其存储在哈希映射中。否则，继续检查其他元素。

下面是上述方法的实现：

C++

// C++ implementation of the
// above approach
#include 
using namespace std;
 
// Function to find the Duplicates,
// if duplicate occurs 2 times or
// more than 2 times in array so,
// it will print duplicate value
// only once at output
void findDuplicates(int arr[], int len)
{
     
    // Initialize ifPresent as false
    bool ifPresent = false;
 
    // ArrayList to store the output
    vector al;
 
    for(int i = 0; i < len - 1; i++)
    {
        for(int j = i + 1; j < len; j++)
        {
            if (arr[i] == arr[j])
            {
                 
                // Checking if element is
                // present in the ArrayList
                // or not if present then break
                auto it = std::find(al.begin(),
                                    al.end(), arr[i]);
                                     
                if (it != al.end())
                {
                    break;
                }
 
                // If element is not present in the
                // ArrayList then add it to ArrayList
                // and make ifPresent at true
                else
                {
                    al.push_back(arr[i]);
                    ifPresent = true;
                }
            }
        }
    }
 
    // If duplicates is present
    // then print ArrayList
    if (ifPresent == true)
    {
        cout << "[" << al[0] << ", ";
        for(int i = 1; i < al.size() - 1; i++)
        {
            cout << al[i] << ", ";
        }
         
        cout << al[al.size() - 1] << "]";
    }
    else
    {
        cout << "No duplicates present in arrays";
    }
}
 
// Driver code
int main()
{
    int arr[] = { 12, 11, 40, 12,
                  5, 6, 5, 12, 11 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    findDuplicates(arr, n);
 
    return 0;
}
 
// This code is contributed by divyeshrabadiya07

Java

// Java implementation of the
// above approach
 
import java.util.ArrayList;
 
public class GFG {
 
    // Function to find the Duplicates,
    // if duplicate occurs 2 times or
    // more than 2 times in
    // array so, it will print duplicate
    // value only once at output
    static void findDuplicates(
      int arr[], int len)
    {
 
        // initialize ifPresent as false
        boolean ifPresent = false;
 
        // ArrayList to store the output
        ArrayList al = new ArrayList();
 
        for (int i = 0; i < len - 1; i++) {
            for (int j = i + 1; j < len; j++) {
                if (arr[i] == arr[j]) {
                    // checking if element is
                    // present in the ArrayList
                    // or not if present then break
                    if (al.contains(arr[i])) {
                        break;
                    }
 
                    // if element is not present in the
                    // ArrayList then add it to ArrayList
                    // and make ifPresent at true
                    else {
                        al.add(arr[i]);
                        ifPresent = true;
                    }
                }
            }
        }
 
        // if duplicates is present
        // then print ArrayList
        if (ifPresent == true) {
 
            System.out.print(al + " ");
        }
        else {
            System.out.print(
                "No duplicates present in arrays");
        }
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        int arr[] = { 12, 11, 40, 12, 5, 6, 5, 12, 11 };
        int n = arr.length;
 
        findDuplicates(arr, n);
    }
}

Python3

# Python3 implementation of the
# above approach
 
# Function to find the Duplicates,
# if duplicate occurs 2 times or
# more than 2 times in array so,
# it will print duplicate value
# only once at output
def findDuplicates(arr, Len):
     
    # Initialize ifPresent as false
    ifPresent = False
 
    # ArrayList to store the output
    a1 = []
    for i in range(Len - 1):
        for j in range(i + 1, Len):
 
            # Checking if element is
            # present in the ArrayList
            # or not if present then break
            if (arr[i] == arr[j]):
                if arr[i] in a1:
                    break
                 
                # If element is not present in the
                # ArrayList then add it to ArrayList
                # and make ifPresent at true
                else:
                    a1.append(arr[i])
                    ifPresent = True
 
    # If duplicates is present
    # then print ArrayList
    if (ifPresent):
        print(a1, end = " ")
    else:
        print("No duplicates present in arrays")
 
# Driver Code
arr = [ 12, 11, 40, 12, 5, 6, 5, 12, 11 ]
n = len(arr)
 
findDuplicates(arr, n)
 
# This code is contributed by rag2127

C#

// C# implementation of the
// above approach
using System;
using System.Collections.Generic;
 
class GFG{
     
// Function to find the Duplicates,
// if duplicate occurs 2 times or
// more than 2 times in array so,
// it will print duplicate value
// only once at output
static void findDuplicates(int[] arr, int len)
{
     
    // Initialize ifPresent as false
    bool ifPresent = false;
 
    // ArrayList to store the output
    List al = new List();
 
    for(int i = 0; i < len - 1; i++)
    {
        for(int j = i + 1; j < len; j++)
        {
            if (arr[i] == arr[j])
            {
                 
                // Checking if element is
                // present in the ArrayList
                // or not if present then break
                if (al.Contains(arr[i]))
                {
                    break;
                }
 
                // If element is not present in the
                // ArrayList then add it to ArrayList
                // and make ifPresent at true
                else
                {
                    al.Add(arr[i]);
                    ifPresent = true;
                }
            }
        }
    }
 
    // If duplicates is present
    // then print ArrayList
    if (ifPresent == true)
    {
        Console.Write("[" + al[0] + ", ");
        for(int i = 1; i < al.Count - 1; i++)
        {
            Console.Write(al[i] + ", ");
        }
        Console.Write(al[al.Count - 1] + "]");
    }
    else
    {
        Console.Write("No duplicates present in arrays");
    }
}
 
// Driver code   
static void Main()
{
    int[] arr = { 12, 11, 40, 12,
                  5, 6, 5, 12, 11 };
    int n = arr.Length;
 
    findDuplicates(arr, n);
}
}
 
// This code is contributed by divyesh072019

Javascript

 
// JavaScript implementation of the
// above approach
 
// Function to find the Duplicates,
// if duplicate occurs 2 times or
// more than 2 times in
// array so, it will print duplicate
// value only once at output
function findDuplicates(arr, len) {
 
    // initialize ifPresent as false
    let ifPresent = false;
 
    // ArrayList to store the output
    let al = new Array();
 
    for (let i = 0; i < len - 1; i++) {
        for (let j = i + 1; j < len; j++) {
            if (arr[i] == arr[j]) {
                // checking if element is
                // present in the ArrayList
                // or not if present then break
                if (al.includes(arr[i])) {
                    break;
                }
 
                // if element is not present in the
                // ArrayList then add it to ArrayList
                // and make ifPresent at true
                else {
                    al.push(arr[i]);
                    ifPresent = true;
                }
            }
        }
    }
 
    // if duplicates is present
    // then print ArrayList
    if (ifPresent == true) {
 
        document.write(`[${al}]`);
    }
    else {
        document.write("No duplicates present in arrays");
    }
}
 
// Driver Code
 
let arr = [12, 11, 40, 12, 5, 6, 5, 12, 11];
let n = arr.length;
 
findDuplicates(arr, n);
 

输出

[12, 11, 5]

时间复杂度： O(N ² )
辅助空间： O(N)

有效方法：使用 unordered_map 进行散列。计算每个元素出现的频率，并打印频率大于 1 的元素。 unordered_map用于整数范围未知。对于Python，使用 Dictionary 将数字存储为键，并将其频率存储为值。字典可用作整数范围未知。

下面是上述方法的实现：

C++

// C++ program to find
// duplicates in the given array
#include 
using namespace std;
 
// function to find and print duplicates
void printDuplicates(int arr[], int n)
{
    // unordered_map to store frequencies
    unordered_map freq;
    for (int i=0; i:: iterator itr;
    for (itr=freq.begin(); itr!=freq.end(); itr++)
    {
        // if frequency is more than 1
        // print the element
        if (itr->second > 1)
        {
            cout << itr->first << " ";
            dup = true;
        }
    }
 
    // no duplicates present
    if (dup == false)
        cout << "-1";
}
 
// Driver program to test above
int main()
{
    int arr[] = {12, 11, 40, 12, 5, 6, 5, 12, 11};
    int n = sizeof(arr) / sizeof(arr[0]);
    printDuplicates(arr, n);
    return 0;
}

Java

// Java program to find
// duplicates in the given array
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
 
public class FindDuplicatedInArray
{
    // Driver program
    public static void main(String[] args)
    {
        int arr[] = {12, 11, 40, 12, 5, 6, 5, 12, 11};
        int n = arr.length;
        printDuplicates(arr, n);
    }
    // function to find and print duplicates
    private static void printDuplicates(int[] arr, int n)
    {
        Map map = new HashMap<>();
        int count = 0;
        boolean dup = false;
        for(int i = 0; i < n; i++){
            if(map.containsKey(arr[i])){
                count = map.get(arr[i]);
                map.put(arr[i], count + 1);
            }
            else{
                map.put(arr[i], 1);
            }
        }
         
        for(Entry entry : map.entrySet())
        {
            // if frequency is more than 1
            // print the element
            if(entry.getValue() > 1){
                System.out.print(entry.getKey()+ " ");
                dup = true;
            }
        }
        // no duplicates present
        if(!dup){
            System.out.println("-1");
        }
    }
}

蟒蛇3

# Python3 program to find duplicates
# using dictionary approach.
def printDuplicates(arr):
    dict = {}
 
    for ele in arr:
        try:
            dict[ele] += 1
        except:
            dict[ele] = 1
             
    for item in dict:
         
         # if frequency is more than 1
         # print the element
        if(dict[item] > 1):
            print(item, end=" ")
 
    print("\n")
 
# Driver Code
if __name__ == "__main__":
    list = [12, 11, 40, 12,
            5, 6, 5, 12, 11]
    printDuplicates(list)
 
# This code is contributed
# by Sushil Bhile

C＃

// C# program to find
// duplicates in the given array
using System;
using System.Collections.Generic;
 
class GFG
{
    // function to find and print duplicates
    static void printDuplicates(int[] arr, int n)
    {
        Dictionary map = new Dictionary();
        int count = 0;
        bool dup = false;
        for (int i = 0; i < n; i++)
        {
            if (map.ContainsKey(arr[i]))
            {
                count = map[arr[i]];
                map[arr[i]]++;
            }
            else
                map.Add(arr[i], 1);
        }
 
        foreach (KeyValuePair entry in map)
        {
            // if frequency is more than 1
            // print the element
            if (entry.Value > 1)
                Console.Write(entry.Key + " ");
            dup = true;
        }
 
        // no duplicates present
        if (!dup)
            Console.WriteLine("-1");
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        int[] arr = { 12, 11, 40, 12,
                     5, 6, 5, 12, 11 };
        int n = arr.Length;
        printDuplicates(arr, n);
    }
}
 
// This code is contributed by
// sanjeev2552

Javascript

 
// JavaScript program to find
// duplicates in the given array
 
// Function to find and print duplicates
function printDuplicates(arr, n)
{
     
    // unordered_map to store frequencies
    var freq = new Map();
    for(let i = 0; i < n; i++)
    {
        if (freq.has(arr[i]))
        {
            freq.set(arr[i], freq.get(arr[i]) + 1);
        }
        else
        {
            freq.set(arr[i], 1);
        }
    }
     
    var dup = false;
    for(let [key, value] of freq)
    {
         
        // If frequency is more than 1
        // print the element
        if (value > 1)
        {
            document.write(key + " ");
            dup = true;
        }
    }
     
    // No duplicates present
    if (dup == false)
        document.write("-1");
}
 
// Driver code
var arr = [ 12, 11, 40, 12,
            5, 6, 5, 12, 11 ];
var n = arr.length;
 
printDuplicates(arr, n);
 
// This code is contributed by lokeshpotta20
 

输出

5 12 11

时间复杂度： O(N)
辅助空间： O(N)

相关帖子：
打印给定整数数组的所有不同元素
在 O(n) 时间和 O(1) 额外空间中查找重复项 |设置 1
在 O(n) 中的数组中重复并使用 O(1) 额外空间 |组 2
打印输入字符串中的所有重复项

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。