Java 如何检查一个列表是否是另一个列表的子集

如何检查列表2是否是列表1的子集？我尝试了containsAll（），但只要列表2中的元素存在于列表1中，它就会给出true。 我想要与标准相同的顺序，而不仅仅是元素。

这是算法

1） 迭代第二个列表

2） 检查元素是否包含在第一个列表中

如果没有返回，则返回false

如果是，则使用从第一个列表中获取该元素的索引

3） 现在，在迭代过程中，检查下一个元素是否等于list1（lastMatchedIndexFromList1++）

如果返回false

---

如果是，请重复步骤3，并在迭代结束时返回true

我对此的实现有点好奇，因此这是我的解决方案：

list1:[1,2,3,4,5]
list2:[1,2,3]

publicstaticvoidmain（字符串[]args）{
List list1=新的ArrayList（）；
清单1.添加（1）；
清单1.添加（2）；
清单1.添加（3）；
清单1.添加（4）；
清单1.添加（5）；
List list2=新的ArrayList（）；
清单2.添加（1）；
清单2.添加（2）；
清单2.添加（3）；
布尔isOrderedSublist=true；
对于（int i=0；i

---

}

迭代

list2

，检查

list1

中是否存在每个元素。最简单的方法是使用to do check操作，它返回此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则返回-1。每个检查操作的时间复杂度是

O（n）

，因为在最坏的情况下它必须迭代整个列表

而如果订购了

list1

，我们可以使用将检查操作性能提高到

O（lgn）

时间复杂度

此处的示例代码：

public static void main(String[] args) {

    List<Integer> list1 = new ArrayList<>();
    list1.add(1);
    list1.add(2);
    list1.add(3);
    list1.add(4);
    list1.add(5);

    List<Integer> list2 = new ArrayList<>();

    list2.add(1);
    list2.add(2);
    list2.add(3);


    boolean isOrderedSublist = true;

    for (int i = 0; i < list2.size(); i++) {

        if(list1.get(i) != (int) list2.get(i)) {
            isOrderedSublist = false;
            break;
        }
    }

    System.out.println("Is ordered: " + isOrderedSublist);
}

List<Integer> list1 = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
List<Integer> list2 = new ArrayList<>(Arrays.asList(1, 2, 5));

boolean contains = true;
int l2 = list2.size();
int currIndex = -1;
for(int j=0;j<l2;j++) {
    int e2 = list2.get(j);
    int i1 = list1.indexOf(e2);
    if(i1 == -1) {
        contains = false;
        break;
    }
    if(i1 > currIndex) {
        currIndex = i1;
    }
}
System.out.println(contains);

list1

和

list2

仅迭代一次，时间复杂度为

O（n+m）

使用以下方法：

boolean contains = true;
int l1 = list1.size(), l2 = list2.size();
int currIndex = 0;
int i;
for(int j=0;j<l2;j++) {
    int e2 = list2.get(j);
    for(i=currIndex;i<l1;i++) {
        if(e2 == list1.get(i)) {
           break;
        }
    }
    if(i == l1) {
        contains = false;
        break;
    }
    currIndex++;
}
System.out.println(contains);

布尔包含（列表、列表子列表）{
返回集合。IndexOfPublist（列表，子列表）！=-1；
}

---

我尝试了下面的代码来查找顺序中的元素

boolean contains(List<?> list, List<?> sublist) {
    return Collections.indexOfSubList(list, sublist) != -1;
}

import java.util.List；
导入java.util.ArrayList；
类OrderArray{
公共静态void main（字符串[]args）{
List listSource=新的ArrayList（）；
对于（int i=1；i）到目前为止，你得到了什么？你到底哪里有问题？向我们展示一些代码，以便我们可以帮助你。@Turing85：我认为OP只是想从API中获得一个现成的方法-手工操作实际上应该是微不足道的。你所说的顺序是什么意思，一个有效的子集可以是
[1,3,5]
？你的意思是
[1,3,2]
应该返回
false
？什么将
列表2:[1,3]
返回？能否确保
列表1
和
列表2
中没有重复的元素，这意味着，
列表1:[1,3,3,4]
无效？对于列表1:[1,2,3,4,5]列表2:[1,3]Collections.indexofpublist将返回-1，而我认为list2被认为是List1的子集，如果您阅读javadoc for List中的第一行，它会说：“一个有序的集合（也称为序列）。”list2也是一个列表，这意味着它是一个序列，在搜索过程中必须保留元素的序列。您可能需要的是一个列表。containsAll（子列表）但than sublist只是一个集合作为参数，而不是序列，元素顺序不再重要。
import java.util.List;
import java.util.ArrayList;
class OrderArray {
  public static void main(String [] args) {
    List listSource = new ArrayList();
    for(int i =1; i <=5; i++) {
        listSource.add(i);
    }
    List target = new ArrayList();
    target.add(2);
    target.add(3);
    boolean isMatched = true;
    int [] indexArray = new int[target.size()];
    for(int i = 0; i< target.size(); i ++) {
        indexArray[i] = listSource.indexOf(target.get(i));
        if ( i !=0 ) {
            if ((indexArray[i] - indexArray[i-1]) != 1) {
                isMatched = false;
                break;
            }
        }
    }
    System.out.println("isMatched:"+isMatched);
  }
}