What is a Linked List?
As you might have guessed, a list is an ordered collection of items. Like any good collection, you want to be able to add and remove items from your list, as well as traverse the list to look at each item or to look for a particular item.
A linked list is a collection of nodes. In Java, a
Nodeis an object that the programmer creates, and contains two references: a references to an object, and a reference to the next
Nodeobject in the list.
Imagine that you've written a
Personclass, and that you would create a ArrayList to store them, but your instructor told you to store them in a linked list instead.
Here's a linked list of five
There are five nodes in this linked list:
Each of these five nodes contains two references:
reference to a
Personobject reference to a
Take a look at each of the five nodes in the linked list. Look at the second reference, that is, the
Nodereference, in each of them. Notice what this
Nodereference refers to.
Node arefers to
Node brefers to
Node crefers to
Node drefers to
Node erefers to
Objectthat represents nothing.
With the exception of
Node e, each node in the linked list refers to the next node. ArrayLists are "random access" data structures. This means that you can refer directly to each element in the ArrayList.
Not so with a linked list. A linked list is a "sequential access" data structure. Each node knows about the node that comes after it, but the node knows nothing about any of the other nodes in the list.
Node erefers to
nullbecause it is the last node in the list. It's the end of the chain, the end of the line. Nothing comes after it.
The list also contains three other references to
Now look at
index. These references refer to nodes in the linked list, too. Take a look and see which nodes each of them refers to.
headrefers to the first node in the linked list.
tailrefers to the last node in the linked list.
indexcan be used by the programmer to keep track of a particular node in the list.
Inserting a Node into the Linked List
You simply set your node reference to refer to the first node in the list. Take a look at the second reference in
newNode. It refers to
But wait. We need to do something else. Now
Node ais at the beginning of the linked list. If you remember,
headis supposed to refer to the first node in the linked list. So we need to make
newNode. Take another look at the picture.
headdoes indeed refer to
newNode, the new first node in the linked list.
How do we add a node into the end of a list? Much like you add a node to the beginning of the list.
You simply make
newNode's second reference refer to nothing (
null>), make the current end of the list (
Node e} refer to
Deleting a Node from a Linked List
How would you remove a node from a linked list?
Take a careful look at this picture. Look at
Node a. Its second reference now refers to
Node c. References can reference only one object at a time. By resetting the reference to
Node c, we lost
Node b, which is as good as deleting it.
Traversing a list
Now we need to do something with the
indexreference. We can use it to refer to whatever node we like. If we want
indexto refer to the first node in the list, we can write
index = a;
If we want to access the
Personobject inside of
Node a, we can write
Person temp = a.getData();
assuming that we have written a
getData()method in the
Nodeclass. But in real linked lists, we don't actually call the individual nodes names like
Node a; Node b; Node c; Node d;
That's what special about linked lists. With the exception of the first node in the list, we refer to each node in terms of the node before it.
Look at the picture of the linked list again.
indexcurrently refers to the first node in the list, the head of the list. Without knowing that
b, how can I now make
indexrefer to node
When we write the
Nodeclass, we will give it two instance variables, one for the reference to the object the node refers to, which in our case is a
Personobject, and one for the reference to the
Nodeobject that comes after it, the next node.
private Person data;
private Node next;
Let's also assume that we've written
datafor that node, and
nextfor that node.
Then if I want
indexto refer to
b, I simply write
index = index.getNext(); //change index so that it refers to the next node
I reset the
indexreference to refer to the node that comes after the node
indexcurrently refers to. In this way, I can walk through the entire list if I like, stopping when I reach a node in which
Implementing A Node
Before we can create a linked list, we first need to create a class to represent one piece of the list, called a node. A node consists of an Object to store the data, and a reference to the next Node in the list.
Since a Node is only useful as a part of a linked list, we can make the implementation of the Node class part of the implementation of the LinkedList. When one class is defined inside another class, we call this a subclass. So, we can define the Node class as a subclass of the LinkedList class. This insures that no one outside of the LinkedList class can use a Node by itself.
Implementing A Linked List
Now that we have a node, how do we construct a linked list? Since each node stores a reference to the next one in the list, we at least need a reference to the beginning of the list. We call this reference the "head" of the list, and from the head we can get to any other node in the list. For convenience, we will also store a reference to the end of the list, called the "tail". This saves us the time it takes to get from the beginning to the end of the list when we need to operate on the last node.
For another level of convenience, we will create a reference called "index", which will be able to move along the nodes in the list. The index allows us to operate on a specific spot in the list without have to walk the list to get to that spot.
The "LinkedList" Class
Next class, we'll actually code up the list.