Array, list, hashSet and dictionary can get us a long ways, but

there are many other types of collections.

All of them have specific advantages.

It's important to always pick the correct collection for

the way the data is being used.

The four collections we've learned about so

far may not always be the best for the job.

Let's briefly look at some of the other less common collection

types provided by the .NET Framework.

We'll start in the System.Collections.Generic namespace.

Here we see another list collection.

It's called LinkedList.

LinkedList is different than the list collection type we used earlier in

this course.

Linked lists are used when we want to be able to quickly add or

remove items without the items in the list being shifted.

This works because linked lists don't use an array internally.

Instead it's a list of individual nodes that are linked to each other.

They're much faster at adding and removing items than an array based list.

On the other hand, linked list don't provide a quick way to index

directly into items in the list using an index.

A queue is like a list except items can only be added to the end of the queue and

they can only be removed from the beginning.

This is why it's called a first in first out or FIFO collection type.

You can think of this just like the line at a grocery store.

The first person in the line is the first person that checks out.

A stack on the other hand is a last in, first out or LIFO collection.

With the stack we can only add and remove items from one end of the stack.

Think of this like a stack of plates.

The last plate, placed on the top of the stack,

is the first one that'll be used when we need a plate.

Queues and stacks are limited in the types of operations we can do with them, but

these limitations allow them to be very efficient at storing and retrieving data.

They're commonly used to simplify how algorithms for

processing data are implemented.

Then we have a number of sorted collection types.

A sortedSet doesn't use an object's hash code to determine if it's in the set.

Instead it keeps the items in the set sorted, so they're arranged in

such a way that it can quickly determine if an item is in the set.

Just like hashSet, it also doesn't allow duplicates.

SortedDictionary works just like a sorted set,

where the keys of the dictionary are sorted.

As with tne normal dictionary, a value can be associated with each key.

SortedSet and sortedDictionary take up less additional memory than hashSet and

the standard dictionary, especially when the number of items becomes large.

And of course they should be used if we want to loop through the items or

keys in a sorted order.

SortedList is actually more like a dictionary than it is a list.

As you can see, it contains both keys and values.

Just like sortedDictionary, the keys of a sorted list are stored in sorted order.

It uses less memory than a sorted dictionary but it's also slower adding and

removing items.