###

Question:

Is `List<T>.Remove(T)`

faster than the `List<T>.RemoveAt(int)`

method in .NET collections? Is speed different for value types or reference types?

###

Solution:1

List.Remove(T) uses IndexOf and RemoveAt(int) in its implementation. So List.RemoveAt(int) is faster.

`public bool Remove(T item) { int index = this.IndexOf(item); if (index >= 0) { this.RemoveAt(index); return true; } return false; } `

###

Solution:2

**Simple answer:**

In general, `RemoveAt`

is quicker, though not always hugely.

**Long answer:**

Let's just consider finding the appropiate item first. The `Remove`

method has to search the list for the item that matches the given object, and is thus `O(n)`

time in general. `RemoveAt`

on a list can simply index the given item, and is thus `O(1)`

.

Now, removing an item from the end of a list is always `O(1)`

of course, but in general removing an item takes `O(n)`

time, because reshuffling needs to be done (moving items after the removed one forward). Therefore, in the general case, the total time complexity for removal is either `O(n) + O(n)`

or `O(n) + O(1)`

for Remove and RemoveAt respectively, hence simply `O(n)`

in either case. However, `RemoveAt`

is guaranteed to be at least as quick, though scaling is the same unless you know you're removing it at/near the end.

###

Solution:3

Remove(T) makes internally a call to RemoveAt(int) so, doing directly a removeAt is faster.

But What do you want to achieve?

###

Solution:4

Given that a .Net is infect a vector (or array), not a linked list, RemoveAt() is quicker.

###

Solution:5

Use `System.Diagnostics.Stopwatch()`

I would have just created a little console app to check which is faster.

**Note:If u also have question or solution just comment us below or mail us on toontricks1994@gmail.com**

EmoticonEmoticon