- A linked list is
a dynamically growing/shrinking
"data structure"
used to organize a collection of
identical objects
-
The objects
are organized
into a chain
-
The objects
are accessed
starting from the
first object in the chain
- Notably: the number of elements in a linked list can increase or can decrease -- that's why a linked list is known as a dynamic data structure (unlike an array where the number of elements does not change).
-
The objects
are organized
into a chain
- We will first look at the characteristics of a linked list; then later we will learn how to manage (traverse, insert, delete) a list
- Recall that is a
reference variable
can hold the address (location)
of some object:
A chain can be created by including an reference variable in the object itself
How to create a linked list in which each element in the list can store one integer value
- NOTE: the next variable in obj1 can be used to find obj2 and thus these 2 objects are considered to be "in the same list"
Step 1: define the right type of variables to realise the linked list
ListElem class provide necessary information to make linked list of integers
class ListElem
{
public:
int value; // Integer
ListElem *next; // Pointer used to make link
};
|
Step 2: how to link one element to another
Instructions to create a "link" from obj1 to obj2
ListElem obj1;
ListElem obj2;
obj1.next = &obj2;
obj2.next = NULL; // 0 is special ("end")
|
Pictorially, this is what is going on inside the computer:
- In general, a chain (list)
will look like this:
- If "ListElem" is the structure/class type that you define to
store linked list elements, that
you need a ListElem reference variable to store the
start of a list of ListElem elements
(this reference variable is usually called "head"):
ListElem head; // a reference variable that points // to the first real element in // a linked list - The empty list is indicated by
setting "head" to the special value NULL ("nowhere"):
head = NULL;
- Traversing a linked list means
visiting every element in the list
- Unlike arrays which is a random access data structure
(meaning that if you want to visit the ith
element in an array, you do not have to
visit the i-1th element),
a
linked list is
a SEQUENTIAL access data structure:
-
if you want to visit the ith
element in a linked list, you have to
visit the i-1th element before doing so.
This is a "natural" consequence from the fact that the information necessary to access the ith element of the list (which is the location (address)) is stored in the i-1th element....
- Hence: access elements in a inked list
always
begin with the first element.
From the first element, we find the location (through the pointer variable) of the next element; and so on.
- The following is a skeletal code to traverse a simple linked list:
// Assume: head points to the first ListElem... ListElem *p; // Auxiliary pointer variable to traverse list p = head; // Very important: start at first element while ( p != NULL ) { cout << p->value; // Access value stored in list element p = p->next; // Visit next element in list }
- The most tedious part of linked list is update: building the list
(and sometime, destroying)
- There are different ways
to add a new object
into the list (or chain):
- always add at the start (head)
of the chain
- always add at the end (tail) of the chain
- Maintain some order based on
the content of the objects
(For example: increasing balance value)
We will discuss these next...
- always add at the start (head)
of the chain