 This time around, we're going to be covering lists, which are quite possibly the most common container, although trees give them a run for their money. Lists, conceptually, are definitely easier to understand than trees. And, being a little bit more of a sophisticated container, we're going to be covering a few more concepts than for the stack or the queue. These concepts tend to have multiple names. I'm not going to be exhaustive, but I will mention a few of them. So now we have the append or hindbind. Most correctly append just means to place onto. It doesn't necessarily mean at the end, but that's by convention what it means. So if we have a 1 on the list and we go to append a 2, the 2 is placed onto the end. The 1 now links to the 2. Append on a 3, the 2 now links to the 3. Append on a 4, the 3 now links to the 4. But we can also prepend or forebind that is attached to the beginning. If we prepend a 0, the 0 is placed and now links to the 1, the former head of the list. There's also insert or embed operations where it can be placed anywhere within the list, not necessarily at the beginning or the end. So if we go to insert a 5 between the 2 and the 3, it will now look something like that. And similarly to the stack and queue, it is possible to remove elements, but if you probably noticed, it can be done anywhere. So if we go ahead and delete the 2, the 1 now points to the 5 instead of to the 2 and then to the 5. There are a few types of lists, and I'm not going to be exhaustive here either, but I will cover the two most common types. First, we have the singly link list, and this is the simplest list, where each node points to the next. The diagrams I was just showing were demonstrating the singly link list specifically, although they wouldn't look that different for a doubly link list. Just the arrows would point in each direction. This makes it traversable in one direction reasonably. Sometimes you will hear only traversable in one direction. It is possible to go the other direction. It's just extremely inefficient. If you need to be doing that, you should be using a doubly link list. And because of its simplicity, it uses the least amount of space. This is because it has a pointer to the next node only, not the previous node as well. That extra pointer takes up more space. Then we have the doubly link list. It's still fairly simple, especially as far as lists go. Each node points to the previous and the next, which enables it to be traversable in either direction reasonably. And there are others, like I had mentioned. You have things like skip list, the free list, jagged poly lists, and so on. These are going to get their own presentations and videos, because these are things that need to be delved into more in-depth. The diagrams I showed before would not do any of those justice. And then as for uses, as I had mentioned, they're easily one of the most common types of containers. And this means they have a lot of uses, far more than I want to list. But if you think about it, you use lists a lot in your real life. And the container is literally just that. Anything that you would make a list of in real life, whether it's just a mental list or a written list, is a use for the list container. This means when you're going through, say, like a source file finding all instances of, I don't know, type declarations, you'd add all those to a list of the type declarations you found. Scanning a directory for all of a certain type of file, you'd add all those files to a list. And they're useful. Very useful. Far more than I could possibly say here and explain. But that's it for lists. Next up, we're going to be getting into trees. And because heaps are a specific type of tree, we'll also be covering heaps.