C# 是否有一种算法可以找到2个列表中项目的所有公共子序列<；列表<；int>>；，维护秩序？

有两个列表。 我必须找到List>中包含的所有整数子序列，其中保留了顺序

List<List<int>> listOfLists1 = new List<List<int>>();
List<int> list1 = new List<int>() { 1, 2, 3, 4, 5, 6 };
List<int> list2 = new List<int>() { 5, 7, 8 };
listOfLists1.Add(list1);
listOfLists1.Add(list2);

List<List<int>> listOfLists2 = new List<List<int>>();
List<int> list3 = new List<int>() { 5, 1, 2, 5 };
List<int> list4 = new List<int>() { 3, 4, 5, 7, 8 };
List<int> list5 = new List<int>() { 5, 6 };
listOfLists2.Add(list3);
listOfLists2.Add(list4);
listOfLists2.Add(list5);

我有两个问题：

有没有一种我不知道的算法可以用来解决这类问题？（这是主要问题）

是否有其他类型的数据结构而不是

类型T的列表列表

及

哪个更适合解决这个问题

我通过创建listOfLists1中每个列表的所有子序列和listOfLists2中每个列表的单独子序列来解决这个问题，保留了项目的顺序，然后我找到了这两个列表中包含的项目（公共项目）

似乎创建所有子序列的步骤是多余的。应该有一个更有效的方法。 先谢谢你

很抱歉，我似乎无法清楚地写出这两种清单。 我的意思是：T型列表和T型列表。 我希望现在情况会更清楚

我用于查找所有子序列的方法是：

private static List<List<T>> FindAllSubSequencesOfConsecutiveCommonItems<T
>(T[] commonItemsArrangemet)
{
    List<List<T>> allSequencesOfConsecutiveCommonItems = new List<List<T>>();
    List<T> sequenceOfConsecutiveCommonItems = new List<T>();
    T currentCommonItem;
    for (int i = 0; i < commonItemsArrangemet.Length; i++)
        {
             currentCommonItem = commonItemsArrangemet[i];
             if (currentCommonItem != null)
             {
                 sequenceOfConsecutiveCommonItems.Add(currentCommonItem );
             {
             else
             {
                 if (sequenceOfConsecutiveCommonItems.Count > 0
                 {
                     allSequencesOfConsecutiveCommonItems.Add(sequenceOfConsecutiveCommonItems);
                     sequenceOfConsecutiveCommonItems = new List<T>();
                 }
             }
         }
     if (sequenceOfConsecutiveCommonItems.Count > 0
     {               
         allSequencesOfConsecutiveCommonItems.Add(sequenceOfConsecutiveCommonItems);
     }

      return allSequencesOfConsecutiveCommonItems;
}

私有静态列表findallsubsequencesofconsecutivecommonims（T[]commonItemsArrangemet）
{
List AllSequencesOfconsutiveCommonItems=新列表（）；
List SequenceOfConceutiveCommonItems=新列表（）；
T当前公共项目；
对于（int i=0；i0
{
所有连续命令的序列。添加（连续命令的序列）；
SequenceOfConceutiveCommonItems=新列表（）；
}
}
}
如果（SequenceOfConceutiveCommonItems.Count>0
{               
所有连续命令的序列。添加（连续命令的序列）；
}
返回连续命令的所有序列；
}

创建项目序列的所有子序列的方法是：

public static List<List<T>> CreateAllSubSequencesOfConsecutiveItemsPreservingSequentialOrder<T>(List<List<T>> allItems, int minimumSequenceLength)
{
    if (allItems == null || allItems.Count == 0 || minimumSequenceLength <= 0)
    {
        return null;
    }
    List<List<T>> sequencesOfConsecutiveItemsPreservingSequentialOrder = new List<List<T>>();
    for (int currentList = 0; currentList < allItems.Count; currentList++)
    {
        List<T> itemsInOneList = allItems[currentList];
        List<List<T>> sequencesOfConsecutiveItemsFromOneList = CreateAllSequencesOfConsecutiveItemsPreservingSequentialOrder(itemsInOneList, minimumSequenceLength);
        sequencesOfConsecutiveItemsPreservingSequentialOrder.AddRange(sequencesOfConsecutiveItemsFromOneList);
    }

    return sequencesOfConsecutiveItemsPreservingSequentialOrder;
}

public static List<List<T>> CreateAllSequencesOfConsecutiveItemsPreservingSequentialOrder<T>(List<T> itemsInOneList, int minimumSequenceLength)
{
    if (itemsInOneList == null || itemsInOneList.Count == 0 || minimumSequenceLength <= 0)
    {
         return null;
    }
    List<List<T>> sequencesOfConsecutiveItemsPreservingSequentialOrder = new List<List<T>>();
    for (int i = 0; i < itemsInOneList.Count; i++)
    {
        List<T> currentSequenceOfConsecutiveItems = new List<T>();
        int j = i;
        while (j < itemsInOneList.Count)
        {
            T currentItem = itemsInOneList[j];
            currentSequenceOfConsecutiveItems .Add(currentItem);
            if (currentSequenceOfConsecutiveItems.Count >= minimumSequenceLength)
            {
                sequencesOfConsecutiveItemsPreservingSequentialOrder.Add(currentSequenceOfConsecutiveItems);
                currentSequenceOfConsecutiveItems = new List<T>(currentSequenceOfConsecutiveItems);
            }
            j++;
        }
   }

    return sequencesOfConsecutiveItemsPreservingSequentialOrder;
}

public static List createAllSubsequenceOffconsecuritiveItemsPreservingSequentialLorder（List allItems，int minimumSequenceLength）
{
如果（allItems==null | | | allItems.Count==0 | | | minimumSequenceLength仍然不清楚为什么您需要一个
列表
。对我来说，您似乎想找到两个
列表
的所有公共子序列。我明白了吗？请向我们展示您的工作。“应该有更有效的方法。”不是一个好问题的基础。我复制了你的列表，并制定了一个（低效的）解决方案，将所有内容都转换为字符串，我可以说没有简单且“快速”的算法适用于你的案例。最多你可以组合一些现有的算法（获取所有子序列，比较交点等）关于你的第二个问题，据我所知，没有一种方法不依赖于所涉及的类型，充其量一些解决方案（如我提出的解决方案）适用于
int
、
string
、
decimal
，等等（所有这些都可以转换为string和back）@Yeldar Kurmangaliyev如果有一个有效的算法可以找到2个列表的所有公共子序列，保持它们的顺序，请告诉我。你如何调用
findallsubsequencesofconsecutivecommonims
？（顺便说一句，在两个
块的“末尾”应该有
}
）
private static List<List<T>> FindAllSubSequencesOfConsecutiveCommonItems<T
>(T[] commonItemsArrangemet)
{
    List<List<T>> allSequencesOfConsecutiveCommonItems = new List<List<T>>();
    List<T> sequenceOfConsecutiveCommonItems = new List<T>();
    T currentCommonItem;
    for (int i = 0; i < commonItemsArrangemet.Length; i++)
        {
             currentCommonItem = commonItemsArrangemet[i];
             if (currentCommonItem != null)
             {
                 sequenceOfConsecutiveCommonItems.Add(currentCommonItem );
             {
             else
             {
                 if (sequenceOfConsecutiveCommonItems.Count > 0
                 {
                     allSequencesOfConsecutiveCommonItems.Add(sequenceOfConsecutiveCommonItems);
                     sequenceOfConsecutiveCommonItems = new List<T>();
                 }
             }
         }
     if (sequenceOfConsecutiveCommonItems.Count > 0
     {               
         allSequencesOfConsecutiveCommonItems.Add(sequenceOfConsecutiveCommonItems);
     }

      return allSequencesOfConsecutiveCommonItems;
}

public static List<List<T>> CreateAllSubSequencesOfConsecutiveItemsPreservingSequentialOrder<T>(List<List<T>> allItems, int minimumSequenceLength)
{
    if (allItems == null || allItems.Count == 0 || minimumSequenceLength <= 0)
    {
        return null;
    }
    List<List<T>> sequencesOfConsecutiveItemsPreservingSequentialOrder = new List<List<T>>();
    for (int currentList = 0; currentList < allItems.Count; currentList++)
    {
        List<T> itemsInOneList = allItems[currentList];
        List<List<T>> sequencesOfConsecutiveItemsFromOneList = CreateAllSequencesOfConsecutiveItemsPreservingSequentialOrder(itemsInOneList, minimumSequenceLength);
        sequencesOfConsecutiveItemsPreservingSequentialOrder.AddRange(sequencesOfConsecutiveItemsFromOneList);
    }

    return sequencesOfConsecutiveItemsPreservingSequentialOrder;
}

public static List<List<T>> CreateAllSequencesOfConsecutiveItemsPreservingSequentialOrder<T>(List<T> itemsInOneList, int minimumSequenceLength)
{
    if (itemsInOneList == null || itemsInOneList.Count == 0 || minimumSequenceLength <= 0)
    {
         return null;
    }
    List<List<T>> sequencesOfConsecutiveItemsPreservingSequentialOrder = new List<List<T>>();
    for (int i = 0; i < itemsInOneList.Count; i++)
    {
        List<T> currentSequenceOfConsecutiveItems = new List<T>();
        int j = i;
        while (j < itemsInOneList.Count)
        {
            T currentItem = itemsInOneList[j];
            currentSequenceOfConsecutiveItems .Add(currentItem);
            if (currentSequenceOfConsecutiveItems.Count >= minimumSequenceLength)
            {
                sequencesOfConsecutiveItemsPreservingSequentialOrder.Add(currentSequenceOfConsecutiveItems);
                currentSequenceOfConsecutiveItems = new List<T>(currentSequenceOfConsecutiveItems);
            }
            j++;
        }
   }

    return sequencesOfConsecutiveItemsPreservingSequentialOrder;
}