# When should I use a List vs a LinkedList

### Question

When is it better to use a List vs a LinkedList?

2
363
8/30/2018 2:14:04 PM

## Edit

Please read the comments to this answer. People claim I did not do proper tests. I agree this should not be an accepted answer. As I was learning I did some tests and felt like sharing them.

I found interesting results:

``````// Temporary class to show the example
class Temp
{
public decimal A, B, C, D;

public Temp(decimal a, decimal b, decimal c, decimal d)
{
A = a;            B = b;            C = c;            D = d;
}
}
``````

``````        LinkedList<Temp> list = new LinkedList<Temp>();

for (var i = 0; i < 12345678; i++)
{
var a = new Temp(i, i, i, i);
}

decimal sum = 0;
foreach (var item in list)
sum += item.A;
``````

## List (2.4 seconds)

``````        List<Temp> list = new List<Temp>(); // 2.4 seconds

for (var i = 0; i < 12345678; i++)
{
var a = new Temp(i, i, i, i);
}

decimal sum = 0;
foreach (var item in list)
sum += item.A;
``````

Even if you only access data essentially it is much slower!! I say never use a linkedList.

Here is another comparison performing a lot of inserts (we plan on inserting an item at the middle of the list)

``````        LinkedList<Temp> list = new LinkedList<Temp>();

for (var i = 0; i < 123456; i++)
{
var a = new Temp(i, i, i, i);

var curNode = list.First;

for (var k = 0; k < i/2; k++) // In order to insert a node at the middle of the list we need to find it
curNode = curNode.Next;

list.AddAfter(curNode, a); // Insert it after
}

decimal sum = 0;
foreach (var item in list)
sum += item.A;
``````

## List (7.26 seconds)

``````        List<Temp> list = new List<Temp>();

for (var i = 0; i < 123456; i++)
{
var a = new Temp(i, i, i, i);

list.Insert(i / 2, a);
}

decimal sum = 0;
foreach (var item in list)
sum += item.A;
``````

## Linked List having reference of location where to insert (.04 seconds)

``````        list.AddLast(new Temp(1,1,1,1));
var referenceNode = list.First;

for (var i = 0; i < 123456; i++)
{
var a = new Temp(i, i, i, i);

}

decimal sum = 0;
foreach (var item in list)
sum += item.A;
``````

So only if you plan on inserting several items and you also somewhere have the reference of where you plan to insert the item then use a linked list. Just because you have to insert a lot of items it does not make it faster because searching the location where you will like to insert it takes time.

97
9/2/2015 4:13:21 PM

In most cases, `List<T>` is more useful. `LinkedList<T>` will have less cost when adding/removing items in the middle of the list, whereas `List<T>` can only cheaply add/remove at the end of the list.
`LinkedList<T>` is only at it's most efficient if you are accessing sequential data (either forwards or backwards) - random access is relatively expensive since it must walk the chain each time (hence why it doesn't have an indexer). However, because a `List<T>` is essentially just an array (with a wrapper) random access is fine.
`List<T>` also offers a lot of support methods - `Find`, `ToArray`, etc; however, these are also available for `LinkedList<T>` with .NET 3.5/C# 3.0 via extension methods - so that is less of a factor.