 Hello, everyone. Welcome back. In this video series, we're going to look at linked lists. So a linked list is a type of data structure, commonly known as ADT or abstract data type. Like an array, a linked list is a linear data structure where all the data are stored in a linear fashion like this here. Unlike an array, though, linked list does not store nodes or elements in a contiguous memory space like you see over here. So therefore, you cannot access these nodes directly like you would with an array where you have access to the indices. The nodes or the elements here, however, are linked together using pointers. And usually, a node contains a data field and a pointer that points to the next node in the list. Therefore, it's not possible to reference any particular node in here except the one in the head if you have a pointer like you see here or the tail through the tail pointer. Now, in order to access that node in here, you will have to traverse the list starting from either the head for a singly linked list or you can also stuff in the tail using the W linked list. Or in this case, if you have a circular linked list, if it is a singular W linked list, you can either go in the direction as well. So these are the three common types of linked lists, a singly linked list, a W linked list, and a circular linked list. In this video series, we're going to focus only on the singly linked list. So let's take a look at another picture over here and in detail. So you can see here is this an example you might see hundreds of times already about singly linked list. At the top right, I put here a class called node. This node class here will represent each of these nodes in here. So the tail, head, the internal nodes here and the previous and current node are all made up of this class called node. This is a generic type of node used in Java where the T here is a generic type, meaning that you can accept any type of data in this node class so that you don't have to have like 10 or 100 classes for each of those types, right? So as you can see here, a linked list is structured or a linked list way. Of course it is not like this in a computer memory, but because we're good with, we're not, we're really bad at memory and our memory capacity is pretty small. So we have to draw this way, help us see things better. Okay, so we have here a singly linked list. In this case, it's one direction only. It's followable if you see this big blue arrow here. Now we'll always start traversal from the head. So we have a head pointer that points to the first node. These are two separate nodes, by the way. This is not that node, we just have as a reference to this node here. So this should have memory address. By deleting this node or deleting this node, that's not deleting the other, okay? So it points to this node here and then this node has internally add another node pointer. I just see over here in the UML, this node called next, which is the same type, right? This is also called the self-referential structure. It references itself. That points to the next node. So in theory, this next node here actually contains the memory address of the second node, which is in this case, the 0x200, okay? And likewise, the next node points to the next one until the last node points to the null value. Now, null value here is not true for every language, of course, but you might have different values like none of a Python or even zero or a nil or things like that, okay? Based on language you learn. So we have a tail pointer that always points to the end of the tail node. And the advantage of the tail node is that if you want to access the last node, it's very quick. It just go right there, right? Go to it. Otherwise, you have to traverse all the way from the head to the end to get the last node. So that's the advantage of having the tail node. But of course, again, you cannot go backward this way. And then down here, you have two purple nodes up here. This is commonly used when you traverse the node on the list or when you make any modification to the list, things like inserting a node in the list, especially between another node like this here or before the current node you're looking for. Or if you want to delete the last node, right? You want to know what the previous node is so that you can access it. You can relink the tail node to the previous node, okay? So that's important in here. So this is what a typical singly linked list diagram would look like and how they're working. So in the next video, we're going to implement this code in Python.