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

Question

Suppose I have three lists:

list1 = a, c, d, r, t

list2 = a, d, t

list3 = a, r, d

Then list2 is contained in list1 but list3 is not because it is not in the same order.

I checked isSubCollection() from CollectionUtils in Apache Commons, and the containsAll() method, but it seems that they don't consider order.

Answer 1

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();
}

This algorithm is linear and requires only 1 iteration in sup list.

UPDATE
If you use linked lists, get operation may run in O(n). So you can use 2 iterators:

boolean isSubsequence(List<?> sup, List<?> sub) {
  Iterator<?> supIt = sup.iterator();
  for (Iterator<?> subIt = sub.iterator(); subIt.hasNext();) {
    Object current = subIt.next();
    boolean found = false;
    while (supIt.hasNext() && !found) {
      found |= supIt.next().equals(current);
    }
    if (!found) {
      return false;
    }
  }
  return true;
} 

But it looks uglier.

Answer 2

Not very efficient but...

You can grab one item in list2 and iterate list1 until you find it or you reach the end of the list. If you do find it, save the index where you found it.

Advance in list2, and iterate list1 from the first index forward.

If you get to the end of list2, it's a sub-list by your criteria.

If you get to the end of list1 and haven't exausted list2, it ain't.

Answer 3

It's not too difficult to whip up on your own.

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;
}

That takes time O(sup.size() + sub.size()), which is optimal in general.

Answer 4

The approach required here is the same independent of language, though you at least need to be sure that it's possible to achieve your goal in Java. The solution is easier to describe using pointers from the C or C++ language, but I'll try to use more general terms here.

Start with the first character of the "containing list" and the "contained list."

• If the two characters match, advance to the next character of both lists.

  • If you reached the end of the "contained list," the answer is yes, it is contained within the other list.

    Otherwise, if you reached the end of the "containing list," the answer is no, it does not contain the "contained list."

    Otherwise, repeat the process with the two now-current characters.

• Otherwise, advance to the next character of the "containing list," and try again against the same character of the "contained list."

  • If you reach the end of the "containing list," the answer is no, it does not contain the "contained list."

    Otherwise, repeat the process with the two now-current characters.

If you draw two arrows ("pointers") to the characters in each list on paper, and only ever bump the arrow in the "contained list" to the right when it matches a character in the "containing list," and bump the arrow in the "containing list" to the right on every step, you'll see how the possibilities for matching success and failure play out.