C# 如何检查数组中是否有重复的值？

这是我的数组

double[] testArray = new double[10];
// will generate a random numbers from 1-20, too lazy to write the code

我想做一个搜索循环来检查是否有重复的值。我该怎么做

---

我不希望使用任何特殊的内置方法，因为这是一个小数组。

您可以使用一点Linq来实现这一点：

if (testArray.Length != testArray.Distinct().Count())
{
    Console.WriteLine("Contains duplicates");
}

扩展方法删除所有重复项，并获取结果集的大小。如果它们完全不同，那么列表中就有一些重复项

或者，这里有一个更复杂的查询，但效率可能会更高一些：

if (testArray.GroupBy(x => x).Any(g => g.Count() > 1))
{
    Console.WriteLine("Contains duplicates");
}

该方法将所有相同的元素分组在一起，如果其中任何一个组有多个元素，则返回

true

以上两种解决方案都是通过使用a来实现的，但您可以直接使用如下一种解决方案：

if (!testArray.All(new HashSet<double>().Add))
{
    Console.WriteLine("Contains duplicates");
}

if（！testArray.All（new HashSet（）.Add））
{
Console.WriteLine（“包含重复项”）；
}

或者，如果您更喜欢完全不依赖Linq的解决方案：

var hashSet = new HashSet<double>();
foreach(var x in testArray) 
{
    if (!hashSet.Add(x)) 
    {
        Console.WriteLine("Contains duplicates");
        break;
    }
}

var hashSet=new hashSet（）；
foreach（测试阵列中的var x）
{
如果（！hashSet.Add（x））
{
Console.WriteLine（“包含重复项”）；
打破
}
}

使用以下方法：

bool CheckUniqueness(double[] values)
{
    var uniqueValues = new HashSet<double>();
    foreach (double d in values)
    {
        if(uniqueValues.Contains(d))
        {
            return false;
        }
        uniqueValues.Add(d);
    }
    return true;
}

bool检查唯一性（双[]值）
{
var uniqueValues=new HashSet（）；
foreach（值为双d）
{
if（唯一值包含（d））
{
返回false；
}
唯一值。添加（d）；
}
返回true；
}

与（OP）10个随机双精度非常快。 重复发生的几率：~0.000002%

static bool repeat(double[] a)
{
    return
        a[0] == a[1] || a[0] == a[2] || a[0] == a[3] || a[0] == a[4] ||
        a[0] == a[5] || a[0] == a[6] || a[0] == a[7] || a[0] == a[8] ||
        a[0] == a[9] || a[1] == a[2] || a[1] == a[3] || a[1] == a[4] ||
        a[1] == a[5] || a[1] == a[6] || a[1] == a[7] || a[1] == a[8] ||
        a[1] == a[9] || a[2] == a[3] || a[2] == a[4] || a[2] == a[5] ||
        a[2] == a[6] || a[2] == a[7] || a[2] == a[8] || a[2] == a[9] ||
        a[3] == a[4] || a[3] == a[5] || a[3] == a[6] || a[3] == a[7] ||
        a[3] == a[8] || a[3] == a[9] || a[4] == a[5] || a[4] == a[6] ||
        a[4] == a[7] || a[4] == a[8] || a[4] == a[9] || a[5] == a[6] ||
        a[5] == a[7] || a[5] == a[8] || a[5] == a[9] || a[6] == a[7] ||
        a[6] == a[8] || a[6] == a[9] || a[7] == a[8] || a[7] == a[9] ||
        a[8] == a[9];
}

更一般，10个数字比上述数字慢2倍，
但是比hashset方法快约7倍

static bool repeat(double[] a)
{
    int k = a.Length - 1;
    if (k < 70)
    {
        double aj;
        for (int i = 0, j; i < k; )
        {
            for (aj = a[k--], j = k; j >= i; j--)
                if (aj == a[j]) return true;
            for (aj = a[i++], j = i; j <= k; j++)
                if (aj == a[j]) return true;
        }
        return false;
    }
    var h = new HashSet<double>();
    while (k >= 0) if (!h.Add(a[k--])) return false;
    return true;
}

静态布尔重复（双[]a）
{
int k=a.长度-1；
if（k<70）
{
双aj；
对于（int i=0，j；i=i；j--）
如果（aj==a[j]）返回true；
对于（aj=a[i++]，j=i；j=0），如果（！h.Add（a[k--]）返回false；
返回true；
}

两行（缓慢重复；）

静态布尔重复（双[]a）
{return（新HashSet（a.Count

看看我的实现，它是

通用的
和
高效的

public static bool HasDuplicates<T>(IList<T> items)
    {
        Dictionary<T, bool> map = new Dictionary<T, bool>();
        for (int i = 0; i < items.Count; i++)
        {
            if (map.ContainsKey(items[i]))
            {
                return true; // has duplicates
            }
            map.Add(items[i], true);
        }
        return false; // no duplicates
    }

我们必须在第一个循环上从
i
初始化
j
，并添加一个（i+1），因为我们要将第一个循环值与同一数组的下一个值进行比较

int[] arr = new int[]{1,2,3,1,4,2,5,4};

//create one loop for arr values
for (int i = 0;  i < arr.Length; i++)
{
    //create nested loop for compare current values with actual value of arr
    for (int j = i+1; j < arr.Length; j++)
    {

        //and here we put our condition
        if (arr[i] == arr[j])
        {
            Console.WriteLine(arr[i]);
        }
    }
}

int[]arr=新的int[]{1,2,3,1,4,2,5,4}；
//为arr值创建一个循环
对于（int i=0；i
通用扩展方法：

public static bool HasDuplicate<T>(this IEnumerable<T> source, IEqualityComparer<T> comparer)
{
    if (source == null)
        throw new ArgumentException(nameof(source));

    HashSet<T> set = new HashSet<T>(comparer);
    foreach (var item in source)
        if (!set.Add(item))
            return true;

    return false;
}

公共静态bool hasdeplicate（此IEnumerable源代码，IEqualityComparer比较器）
{
if（source==null）
抛出新ArgumentException（nameof（source））；
HashSet=newhashset（比较器）；
foreach（源中的var项）
如果（！set.Add（项目））
返回true；
返回false；
}
int[]nums=newint[]{1,2,3,4,5}；
Console.WriteLine（anyreplicate（nums））；
}
/// 
///如果数组中至少存在重复项，则返回true。
/// 
/// 
静态bool AnyDuplicate（int[]数字）
{            
for（int i=0；i
使用哈希集将成员添加到，然后检查当前成员是否以前出现过

public bool ContainsDuplicate(double[] nums) 
{
            int size = nums.Length;
            HashSet<double> set1 = new HashSet<double>();

            for (int i = 0; i < size; i++)
            {
                if (set1.Contains(nums[i]))
                {
                    return true;
                }
                else
                {
                    set1.Add(nums[i]);
                }
            }
            return false;
}

public bool包含两个（双[]nums）
{
int size=nums.Length；
HashSet set1=新的HashSet（）；
对于（int i=0；i
哦，好的，谢谢。Distinct（）.Count（）通常应该做什么？哦，我明白了。所以如果我只想检查重复项，那么我就删除Distinct（）和Count（）对吗方法表示它在结果集的大小上被复制了多少次？@Mike no
Count
将返回集合中的项目数，即
testArray.Length==testArray.Count（）
。要获得重复的数量，只需减去这两个，即
testArray.Length-testArray.Distinct（）.Count（）
好的，谢谢第二个很好地检查了是否有重复。谢谢，我稍微修改了它，使用了
IEnumerable
而不是
IList
。我还将它作为一个扩展方法。
public static bool HasDuplicate<T>(this IEnumerable<T> source, IEqualityComparer<T> comparer)
{
    if (source == null)
        throw new ArgumentException(nameof(source));

    HashSet<T> set = new HashSet<T>(comparer);
    foreach (var item in source)
        if (!set.Add(item))
            return true;

    return false;
}

        int[] nums = new int[] { 1, 2, 3, 4, 5};



        Console.WriteLine(AnyDuplicate(nums));
    }
    /// <summary>
    /// Returns true if there is at least a duplicate in the array.
    /// </summary>
    /// <returns></returns>
    static bool AnyDuplicate(int[] numbers)
    {            
        for (int i = 0; i < numbers.Length; i++)
        {
            for (int j = i + 1; j < numbers.Length; j++)
            {
                if (numbers[i] == numbers[j])
                {
                    return true; 
                }
            }
        }
        return false;

public bool ContainsDuplicate(double[] nums) 
{
            int size = nums.Length;
            HashSet<double> set1 = new HashSet<double>();

            for (int i = 0; i < size; i++)
            {
                if (set1.Contains(nums[i]))
                {
                    return true;
                }
                else
                {
                    set1.Add(nums[i]);
                }
            }
            return false;
}