Time complexity of contains(Object o), in an ArrayList of Objects

Question

As the title says, I was wondering what the time complexity of the contains() method of an ArrayList is.

Answer 1

it's O(n) for ArrayList

Answer 2

O(n)

The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. The add operation runs in amortized constant time, that is, adding n elements requires O(n) time. All of the other operations run in linear time (roughly speaking). The constant factor is low compared to that for the LinkedList implementation.

http://download.oracle.com/javase/6/docs/api/java/util/ArrayList.html

Answer 3

its O(n). contains(Object o) is implemented on indexOf() which takes O(n). So complexity of contains(Object o) is defensively O(n)

Here are some other if you need:

add() - O(1)
add(index, element) – O(n)
get() – O(1)
set() – O(1)
remove() –  (n)
indexOf()` – O(n)

Answer 4

If you look into the source code for ArrayList and check its contains method it looks as below:

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

contains delegates the check to the indexOf method. So, if we check the indexOf implementation it is as follows:

public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

As it can be seen from the code, in order to find an index of a given element, one, in the worst case, must iterate through the whole array. As a size of the array grows and so does the search time by an element. Hence, the time complexity of contains method is O(n), where n is the number of elements in the list.