主页 / 问题 / 1237440
Accepted
Potion
Asked:2022-01-29 18:53:21 +0800 CST2022-01-29 18:53:21 +0800 CST

行块的连接

  • 772

我有一个字符串列表的列表。

List<string> firstList = new List<string>(){"one","two,"three"};
List<string> secondList = new List<string>(){"three","four,"five"};
List<string> thirdList = new List<string>(){"ten","eleven,"twelve"};

List<List<string>> blocksOfStrings = new List<List<string>>(){firstList,secondList,thirdList};

而且您需要编写一个方法，将工作表与相交值结合起来。那些。在这种情况下，我们让 firstList 和 secondList 包含相同的字符串 - “three”，这意味着它们需要合并为一个 List 并删除重复项

为此写了一个方法，

List<List<string>> MergeBlockOfStrings(List<List<string>> blocksOfStrings)
{
    List<List<string>> newBlockOfStrings = new List<List<string>>();

    foreach (var block in blocksOfStrings)
    {
        foreach (var block2 in blocksOfStrings)
        {
            if (block2 != block)
            {
                foreach (var str1 in block)
                {
                    foreach (var str2 in block2)
                    {
                        if (str1 == str2)
                        {
                            var newBlock = new List<string>();
                            foreach (var firstBlockString in block)
                            {
                                if (!newBlock.Contains(firstBlockString))
                                {
                                    newBlock.Add(firstBlockString);
                                }
                            }
                            foreach (var secondBlockString in block2)
                            {
                                if (!newBlock.Contains(secondBlockString))
                                {
                                    newBlock.Add(secondBlockString);
                                }
                            }
                            newBlockOfStrings.Add(newBlock);
                        }
                    }
                }
            }
        }
    }

    return newBlockOfStrings;
}

但它很笨重，看起来很糟糕。有没有办法让这更容易和更容易理解，例如，通过 LINQ？

它应该如何工作

在方法的入口处

List<string> firstList = new List<string>(){"one","two","three"};
List<string> secondList = new List<string>(){"three","four","five"};
List<string> thirdList = new List<string>(){"ten","eleven","twelve"};

方法使用

List<List<string>> MergedBlocksOfStrings = MergeBlockOfStrings(blockOfStrings);

输出应该是

List<string> mergedList = new List<string>(){"one","two","three","four","five"};
List<string> thirdList = new List<string>(){"ten","eleven","twelve"};

List<List<string>> blocksOfStrings = new List<List<string>>(){mergedList,thirdList};
c#

2 个回答

  1. Best Answer

    如果有人在评论中写下该算法的有效性及其缺陷，我会很高兴。

    主意

    1. 取最左边的方块left
    2. 我们依次检查块列表的右侧部分，那里是否存在块right，其元素存在于列表中left。如果是，请参阅步骤 3，如果不是，请参阅步骤 7
    3. 将列表合并为一个join
    4. 从原始块列表中删除left和right
    5. 将left新块放置到位join
    6. 在列表右侧结束循环
    7. 如果该块left不是列表中的最后一个块，则转到列表中的下一个块left并重复步骤 2。否则，结束算法

    因此，预期的结果将在原始列表中。

    编码：

    private static async Task Main(string[] args)
{
    List<string> firstList = new List<string>() { "one", "two", "three" };
    List<string> secondList = new List<string>() { "three", "four", "five" };
    List<string> thirdList = new List<string>() { "ten", "eleven", "twelve" };

    List<List<string>> blocksOfStrings = new List<List<string>>() { firstList, secondList, thirdList};

    var result = Intersect(blocksOfStrings);
}

private static List<List<string>> Intersect(List<List<string>> blocksOfStrings)
{
    for (var i = 0; i < blocksOfStrings.Count; i++)
    {
        var left = blocksOfStrings[i];

        for (var j = i + 1; j < blocksOfStrings.Count; j++)
        {
            var right = blocksOfStrings[j];

            if (AreIntersect(left, right))
            {
                var join = left.Union(right).ToList();
                blocksOfStrings.Remove(left);
                blocksOfStrings.Remove(right);
                blocksOfStrings.Insert(i, join);
                i--;
                break;
            }
        }
    }

    return blocksOfStrings;
}

private static bool AreIntersect(List<string> first, List<string> second)
{
    return first.Intersect(second).Any();
}
    • 1

  2. 对于 union，你可以使用 Concat，对于重复的 Union，

    List<string> firstList = new List<string>() { "one", "two", "three"};
List<string> secondList = new List<string>() { "three", "four", "five"};
List<string> thirdList = new List<string>() { "ten", "eleven", "twelve"};

List<string> result = firstList.Union(secondList).Union(thirdList).ToList();

    如果 List 包含一个类，那么你仍然可以通过一个通用接口来组合它，例如：

    firstList.Cast<ICommon>().Concat(secondList.Cast<ICommon>()).Concat(thirdList.Cast<ICommon>());
    • 0

相关问题