如何确定一个列表是否以相同的顺序包含在另一个列表中（在Java中）？

假设我有三个列表：

列表1=a、c、d、r、t

列表2=a，d，t

列表3=a、r、d

然后list2包含在list1中，但list3不包含，因为它的顺序不同

---

我在Apache Cuthon中使用了<代码> iSubCopyToMs/<代码>和 CuthsAsLoad（）/Case>方法，但是它们似乎没有考虑顺序。

不是非常有效，但是…

您可以在列表2中抓取一个项目并迭代列表1，直到找到它或到达列表的末尾。如果确实找到了，请将索引保存在找到它的位置

在列表2中前进，并从第一个索引向前迭代列表1

如果您到达列表2的末尾，根据您的标准，它是一个子列表

---

如果你到了列表1的末尾，还没有检查列表2，它就不是了。

效率不高，但是

您可以在列表2中抓取一个项目并迭代列表1，直到找到它或到达列表的末尾。如果确实找到了，请将索引保存在找到它的位置

在列表2中前进，并从第一个索引向前迭代列表1

如果您到达列表2的末尾，根据您的标准，它是一个子列表

---

如果你到了列表1的末尾，还没有检查列表2，那就不是了。

你自己动手做并不难

boolean isSubSequence(List<?> sup, List<?> sub) {
  for (Object o : sub) {
    int index = sup.indexOf(o);
    if (index == -1) { return false; }
    sup = sup.subList(index + 1, sup.size());
  }
  return true;
}

boolean isSubSequence（列表辅助，列表辅助）{
用于（对象o:sub）{
int index=辅助索引OF（o）；
如果（索引==-1）{return false；}
sup=辅助子列表（索引+1，辅助大小（））；
}
返回true；
}

---

这需要时间O（sup.size（）+sub.size（）），这通常是最佳的。

你自己动手做并不难

boolean isSubSequence(List<?> sup, List<?> sub) {
  for (Object o : sub) {
    int index = sup.indexOf(o);
    if (index == -1) { return false; }
    sup = sup.subList(index + 1, sup.size());
  }
  return true;
}

boolean isSubsequence(List<?> sup, List<?> sub) {
    int current = 0;
    for (Object obj: sup) {
      if (current == sub.size()) {
         return true;
      }
      if (obj.equals(sub.get(current)) {
        current++;
      }
    }
    return current == sub.size();
}

boolean isSubSequence（列表辅助，列表辅助）{
用于（对象o:sub）{
int index=辅助索引OF（o）；
如果（索引==-1）{return false；}
sup=辅助子列表（索引+1，辅助大小（））；
}
返回true；
}

这需要时间O（sup.size（）+sub.size（）），这通常是最佳的

boolean isSubsequence(List<?> sup, List<?> sub) {
    int current = 0;
    for (Object obj: sup) {
      if (current == sub.size()) {
         return true;
      }
      if (obj.equals(sub.get(current)) {
        current++;
      }
    }
    return current == sub.size();
}

但它看起来更丑

---

但它看起来更丑

这里所需的方法与语言无关，尽管您至少需要确保可以用Java实现您的目标。使用C或C++语言的指针更容易描述该解决方案，但我将尝试使用更一般的术语。 从“包含列表”和“包含列表”的第一个字符开始

• 如果两个字符匹配，则前进到两个列表的下一个字符
  • 如果您到达“包含列表”的末尾，答案是“是”，它包含在另一个列表中
    否则，如果您到达“包含列表”的末尾，则答案为“否”，它不包含“包含列表”
    否则，使用当前的两个字符重复此过程

• 否则，请前进到“包含列表”的下一个字符，然后针对“包含列表”的同一个字符重试
  • 如果您到达“包含列表”的末尾，答案是否，它不包含“包含列表”
    否则，使用当前的两个字符重复此过程

---

如果您在纸上绘制两个箭头（“指针”）指向每个列表中的字符，并且仅当“包含列表”中的箭头与“包含列表”中的字符匹配时，才会向右撞击“包含列表”中的箭头，并且在每个步骤上向右撞击“包含列表”中的箭头，您将看到匹配成功和失败的可能性是如何发挥的。

此处所需的方法与语言无关，但您至少需要确保在Java中实现您的目标是可能的。使用C或C++语言的指针更容易描述该解决方案，但我将尝试使用更一般的术语。 从“包含列表”和“包含列表”的第一个字符开始

• 如果两个字符匹配，则前进到两个列表的下一个字符
  • 如果您到达“包含列表”的末尾，答案是“是”，它包含在另一个列表中
    否则，如果您到达“包含列表”的末尾，则答案为“否”，它不包含“包含列表”
    否则，使用当前的两个字符重复此过程

• 否则，请前进到“包含列表”的下一个字符，然后针对“包含列表”的同一个字符重试
  • 如果您到达“包含列表”的末尾，答案是否，它不包含“包含列表”
    否则，使用当前的两个字符重复此过程

---

如果您在纸上绘制两个箭头（“指针”）指向每个列表中的字符，并且仅当“包含列表”中的箭头与“包含列表”中的字符匹配时，才会向右撞击“包含列表”中的箭头，并且在每个步骤上向右撞击“包含列表”中的箭头，您将看到匹配成功和失败的可能性是如何发挥的。

可能必须为列表2/列表3中的每个元素循环，并检查索引是否大于上次找到的索引可能必须为列表2/列表3中的每个元素循环，并检查索引是否大于上次找到的索引是否确实运行

子列表

在O（1）中？它几乎总是在

O（1）

中运行（例如，在

ArrayList

和

ImmutableList

），但即使列表也是

LinkedList

，而

子列表在
索引中花费的时间是线性的，整个算法也是O（sup.size（）+sub.size（））…对于您的算法来说，情况并非如此。根据
抽象列表
实现，
子列表
创建新对象，该对象封装当前列表。因此，在您的情况下，您可能有子列表从子列表从子列表从子列表从子列表等。。。在我的算法中，使用
get
选择problect，这可能是