使用 List 查找重复的整数

Question

我做了一个函数来查找重复的整数并存储和输出它们的数量，因为它们是数组。 我创建名为“Hit”的列表，用于排除重复编号的操作。如果我曾经找到数字的所有重复项，我就不需要再做一次了。 但是“命中”列表不起作用。它给了我超出范围的错误。 例如：我有数组 int[] in_number = {1, 2, 2, 4, 5, 6, 6}; 没有“命中” 它会给我。我已经这样做了。它有效。

0
1 2
1 2
3
4
5 6 
5 6

输出

我尝试使用“Hit”（它不起作用）

0
1 2
3
4
5 6

但我想要（最好的方式）

1 2
5 6 

代码如下：

namespace arrow
{
    class Program
    {     
        static void Main(string[] args)
        {        
        int Min = 0;
        int Max = 10;
        int[] in_number = new int[100]; 
        Random randNum = new Random();
        for (int i = 0; i < in_number.Length; i++)
        {
            in_number[i] = randNum.Next(Min, Max);
        }                                           
        duplicate_number_List (in_number);                       
        }

        static void dupnumlist (int[] in_number) // Find duplicate numbers  
                {                        
                    List<List<int>> duplicate_pair = new List<List<int>>();
                    List<int> Hit = new List<int>();            
                    for (int i = 1; i < in_number.Length; i++)            
                    {                                                            
                        List<int> SubList = new List<int>();
                        foreach (int number in Hit)
                            {
                                if (number == in_number[i]) // Will match once 
                                {
                                    i++; // go to next iteration; passing unnecessary
                                }
                            }

                        for (int j = 0; j < in_number.Length; j++)
                        {
                            if (in_number[j]==in_number[i])
                            {                        
                                SubList.Add(j);
                                Hit.Add(in_number[i]);
                            }
                        }
                        duplicate_pair.Add(SubList);                
                    }  

                    foreach (var sublist in duplicate_pair)
                    {
                        foreach (var value in sublist)
                        {
                        Console.Write(value);
                        Console.Write(' ');
                        }
                        Console.WriteLine();
                    }
                    foreach (var value in Hit)
                    {
                        Console.Write(value);
                        Console.Write(' ');
                    }
                    Console.WriteLine();
                }              
    }
}

我不想使用内置函数

Answer 1

听起来您正在寻找这样的东西：

int[] in_number = {1, 2, 2, 4, 5, 6, 6};
var duplicates = 
    from a in in_number.Select((value, index) => new { value, index })
    group a by a.value into g
    where g.Count() > 1
    select g.First();

第一行选择整数列表中的每个数字及其索引作为对。第二行将具有相同值的对组合在一起。第三行过滤掉任何只有一个成员的组。最后，最后一行返回每个组中的第一对，其中将包含值以及最低索引。

然后您可以遍历重复项并像这样写出它们：

foreach (var dup in duplicates)
{
    Console.WriteLine("{0} {1}", dup.index, dup.value);
}

更新

如果你可以假设输入数组已经排序，这里是一个只使用字典的解决方案：

var previousValue = in_number[0];
var duplicates = new Dictionary<int, int>();
for(int i = 1; i < in_number.Length; i++) // Note: starting at 1 instead of 0
{
    if (previousValue == in_number[i] && !duplicates.ContainsKey(i))
    {
        duplicates.Add(previousValue, i - 1);
    }
    previousValue = in_number[i];
}

如果输入数组可能没有排序，那就有点难度了，不过你还是可以用一对Dictionaries做到的：

var first = new Dictionary<int, int>();      // Stores the first instance of each value and its index
var duplicates = new Dictionary<int, int>(); // Stores any subsequent instances with the previous index
for(int i = 0; i < in_number.Length; i++)
{
    if (!first.ContainsKey(in_number[i]))
    {
        first.Add(in_number[i], i);
    } 
    else if (!duplicates.ContainsKey(in_number[i]))
    {
        duplicates.Add(in_number[i], first[in_number[i]]);
    }
}

Answer 2

为什么不使用HashTable 类？将Key 和Value 属性上的值存储在HashTable 上，然后如果它等于先前的条目，则根本不存储它。

参考this，我保证这是最简单的方法。