多列表关联元素聚合需求实现及代码调试求助

输入示例 #

List<List<int>> inputLists = new List<List<int>>
{
    new List<int> { 4, 2, 1 },
    new List<int> { 5, 9, 1 },
    new List<int> { 6, 1, 2 },
    new List<int> { 9, 4, 3 },
    new List<int> { 9, 4, 2 }
};

需求说明 #

将输入列表中两两相互关联的元素聚合为更大的列表，最终结果列表中的元素数量需至少为4个。上述示例的预期结果是仅含一个元素的List<List<int>>：{4,2,1,9}（元素排序无关）。

关联逻辑 #

• 9与1在第二个列表中共存
• 9与2在最后一个列表中共存
• 9与4在第四个/最后一个列表中共存
• 4、2、1本身在第一个列表中共存

用户代码（存在逻辑问题） #

internal void Test()
{
    List<List<int>> inputLists = new List<List<int>>
{
    new List<int> { 4, 2, 1 },
    new List<int> { 5, 9, 1 },
    new List<int> { 6, 1, 2 },
    new List<int> { 9, 4, 3 },
    new List<int> { 9, 4, 2 }
};

    foreach (var input in inputLists)
    {
        IEnumerable<IEnumerable<int>> results = Array.Empty<IEnumerable<int>>();
        input.ForEach(number =>
        {
            //first step: getting all numbers that are related to "number"
            //number is 4 | related ones are: 4, 2, 1, 9, 3
            IEnumerable<int> everyFrickingNumberAppearing = Array.Empty<int>();
            inputLists.Where(inputList => inputList.Contains(number)).ToList()
            .ForEach(inputList =>
            everyFrickingNumberAppearing =   everyFrickingNumberAppearing.Concat(inputList).Distinct()
            );


            var IReallyDontKnowWhatIAmDoing = everyFrickingNumberAppearing
            //trying out every number
            .Where(probablyRelatedNumber => inputLists
            //looking if there is at least one element that
            //appears in at least one list together with "number"
            .Any(list => list.Contains(probablyRelatedNumber) && list.Contains(number)))
            .ToArray();
            //appending all related numbers of "number" to results
            results.Append(IReallyDontKnowWhatIAmDoing);
        });
        //going through results
        results.ToList().ForEach(r =>
        {
            //selecting only nums which appear in every result
            var importantNums = r.Select(num => results.ToList().All(l => l.Contains(num)));
            //print it
            importantNums.ToList().ForEach(n => Console.Write($"{n} "));
            Console.WriteLine();
        });
    }
}

代码问题分析 #

1. IEnumerable不可变性误用：results.Append(...)不会修改原results，因为IEnumerable是惰性求值且不可变的，必须重新赋值才能保存新增元素。
2. 冗余循环：外层foreach (var input in inputLists)会重复处理每个子列表，导致多次无效计算。
3. 关联逻辑不完整：仅计算单个元素的直接关联，未迭代扩展所有间接关联的元素（比如没把和9关联的元素反向关联回4、2、1）。
4. 结果筛选逻辑错误：importantNums取所有结果列表都包含的元素，和“聚合所有关联元素”的需求完全相悖，反而过滤了大部分目标元素。

修复后的代码 #

internal void Test()
{
    List<List<int>> inputLists = new List<List<int>>
    {
        new List<int> { 4, 2, 1 },
        new List<int> { 5, 9, 1 },
        new List<int> { 6, 1, 2 },
        new List<int> { 9, 4, 3 },
        new List<int> { 9, 4, 2 }
    };

    // 存储已处理数字，避免重复聚合
    HashSet<int> processedNumbers = new HashSet<int>();
    List<List<int>> finalResults = new List<List<int>>();

    foreach (var subList in inputLists)
    {
        foreach (int num in subList)
        {
            if (processedNumbers.Contains(num))
                continue;

            // 广度优先搜索（BFS）遍历所有关联数字
            Queue<int> queue = new Queue<int>();
            HashSet<int> connectedNumbers = new HashSet<int>();
            queue.Enqueue(num);
            connectedNumbers.Add(num);

            while (queue.Count > 0)
            {
                int current = queue.Dequeue();
                // 找出包含当前数字的所有子列表，提取其中的关联数字
                var relatedLists = inputLists.Where(l => l.Contains(current));
                foreach (var list in relatedLists)
                {
                    foreach (int relatedNum in list)
                    {
                        if (!connectedNumbers.Contains(relatedNum))
                        {
                            connectedNumbers.Add(relatedNum);
                            queue.Enqueue(relatedNum);
                        }
                    }
                }
            }

            // 标记所有已处理的关联数字
            foreach (int connectedNum in connectedNumbers)
            {
                processedNumbers.Add(connectedNum);
            }

            // 只保留元素数量≥4的关联集合
            if (connectedNumbers.Count >= 4)
            {
                finalResults.Add(connectedNumbers.ToList());
            }
        }
    }

    // 输出最终结果
    foreach (var result in finalResults)
    {
        Console.WriteLine($"聚合结果: {string.Join(", ", result)}");
    }
}

修复思路说明 #

1. 广度优先搜索（BFS）：从任意未处理数字出发，遍历所有直接/间接关联的元素，确保所有关联元素都被聚合。
2. 去重机制：用HashSet存储已处理数字和当前关联集合，避免重复计算和重复元素。
3. 结果筛选：仅保留元素数量≥4的关联集合，贴合需求要求。
4. 优化循环：每个数字仅处理一次，避免冗余计算。

内容的提问来源于stack exchange，提问作者CShark