LINKED LIST
Given an ordered-list:
What happens when we add/delete an element to the list?
In the array implementation, such cases require heavy
data movement which is very costly.
In most cases, the data is processed in a strictly sequential
order.
Therefore all that is required is the access to next element.
In our previous mapping, the next element happens to
be the elemental at the next index in the array.
If we can some how tell where the next element is
stored, we can eliminate this restriction of placing the
next element at the next physical location!
This gives rise to the notion of logical adjacency as
opposed to physical adjacency.
In that case, in order to access the elements
of the list, all we need is a starting point and
some mechanism to move from one element
to the next.
In other words, we need a starting point
and a link from one element to the next.
1 2 3 4
We can only travel in the direction of the link.
We have a chain like structure and we can access
the elements in the chain by just following the links
in the chain.
Such an organization is known as a linked-list.
CHAINING & LINK LIST
LINKED-LISTS
This organization rids us from the
requirement to maintain the logical as
well as physical adjacency.
Now all we need to maintain is the logical
sequences and two logically adjacent
elements need to not be physically
next to each other.
TRAIN & LINK LIST
Engine
Bogies
Starting point of linklist
root 5 8 10 15
data elements
BOGIE
Trolley
Connector
Next Data
Node
LINKED-LISTS
We can implement this organization by storing the information
and handle to the next element with the other data as follows:-
struct node {
node * next; // handle to next list element
data_type data;
};
node * root; // starting point - handle to first list element
root = // initialize head to - the end marker
LINKED-LISTS
A list node and the resulting list looks
like as shown below:
Data Next
root 2 5 8 10 15
LINKED-LISTS – TRAVERSAL
void traverse (node * root)
{
node * current = root;
while ( current != ) {
process data at current;
current = next field of current element
}
} root 2 5 8 10 15
current
LINKED-LIST
ADD AN ELEMENT AFTER CURRENT ELEMENT
void add (node * current, data_type data)
{
node * new_element;
new_element = get a new element; //step 1
data field of new_element = data; //step 1
next field of new_element = next field of current; //step 2
next field of current = new_element; //step 3
}
LINKED-LIST – INSERTION
root 2 5 8 10 15
6
Curr Step 1
new_element = get a new element;
new_Element data field of new_element = data;
root 2 5 8 10 15
Curr Step 2
6
new_Element next field of new_Element =
next field of current;
root 2 5 8 10 15
Curr 6
Step 3
new_ Element next field of current = new_element;
LINKED-LIST – WARNING:
FRAGILE, HANDLE LINKS WITH CARE
If one link is broken, you loose access to all
subsequent elements.
What happens if you swap the following two lines in
add:
next field of new_element = next field of current; //step 2
next field of current = new_element; //step 3
to
next field of current = new_element; //step 2
next field of new_element = next field of current; //step 3
root 2 5 8 10 15
7
Step 1 Curr
new_element = get a new element
data field of new_element = data new_element
root 2 5 8 10 15
7
Curr
Step 2
New_element next field of current = new_element;
This part is no longer accessible
Step 3
next field of new_element =
next field of current;
root 2 5 8 10 15
7
Curr
new_element
LINKED-LIST
DELETE AN ELEMENT AFTER CURRENT ELEMENT
void delete (node * current)
{
node * temp = next field of current;
next field of current = next field of next element of current
// same as next field of temp
discard temp
}
LINKED LIST - DELETION
root 5 6 9 12 15
node * temp = next field of current; Curr temp
root 5 6 9 12 15
next field of current = temp
next filed of next element of current This element is no longer
Curr accessible
GARBAGE
When all access paths to a data object are destroyed
but the data object continues to exist, the data object is
said to be garbage.
Garbage is a less serious but still troublesome problem.
A data object that has become garbage ties up storage
that might otherwise be reallocated for another
purpose.
A buildup of garbage can force the program to terminate
prematurely because of lack of available free storage.
root 5 6 9 12 15
temp
This element is no longer
Curr accessible
GARBAGE
This part is no longer accessible
root 2 5 8 10 15
7
Curr
New Element
LINKED LIST - IMPLEMENTATION USING
DYNAMICALLY ALLOCATED STORAGE
Handle will be the pointer (memory address) of an element in
the linked list.
Space may be acquired at run-time on request from free store
using new.
At a point in time when a memory area pointed to by a pointer
is no longer required, it can be returned back to free store
using delete.
We should always return storage after we no longer need it.
Once an area is freed, it is improper and quite dangerous to
use it.
DANGLING REFERENCES
A dangling reference is an access path that continues to exist after the life
time of the associated data object.
ObjectTypeA *p, *q;
p
p = new ObjectTypeA;
q = p; q
delete q; q = NULL; p
What happens to p?
q
It’s a “dangling reference”!
GARBAGE
When all access paths to a data object are destroyed but the data object continues
to exist, the data object is said to be garbage.
ObjectTypeA *p, *q;
p
p = new ObjectTypeA;
q = new ObjectTypeA; q
p
q = p;
What happens to the space that was pointed to by q?
It’s “garbage”!
DANGLING REFERENCES AND
GARBAGE
Dangling references are particularly serious
problem for storage management, as they might
compromise the integrity of the entire run-time
structure during program execution.
Garbage is a less serious but still troublesome
problem. A data object that has become
garbage ties up storage that might otherwise be
reallocated for another purpose.
A buildup of garbage can force the program to
terminate prematurely because of lack of
available free storage.
LINKED LIST - IMPLEMENTATION USING
DYNAMICALLY ALLOCATED STORAGE
struct Node {
int data;
Node *next;
};
Class LinkedList {
private:
Node * root;
public:
LinkedList() { root = NULL; }
void add (int data);
void remove (int data);
void print ();
~LinkedList();
};
void LinkedList:: print()
{
Node *current = root;
while (current != NULL) {
cout << current->data;
current = current->next;
}
root 2 5 8 10 15
current
bool LinkedList::add(int data)
{
Node *temp = new Node;
if (temp == NULL) return false;
else {
temp->data = data;
Node *current, *previous;
current = root;
while (current != NULL && current->data < data;) {
previous = current;
current = current->next;
}
temp -> next = current;
if (current == root) root = temp;
temp
else previous->next = temp;
return true;
} 9
}
root 2 5 8 10 15
Previous Current
void LinkedList::remove(int data)
{
Node *current, *previous;
current = root;
while (current != NULL && current->data < data) {
previous = current;
current = current->next
}
if (current != NULL && current->data == data) {
if (current == root)
root = root -> next;
else
previous->next = current->next;
delete current;
}
}
THE DESTRUCTOR
The destructor is the counterpart of the constructor.
It is a member function that is called automatically when
a class object goes out of scope.
Its purpose is to perform any cleanup work necessary
before an object is destroyed.
Destructors are required for more complicated classes,
where they're used to release dynamically allocated
memory.
~LINKEDLIST() { }
struct Node { int data; Node *next; };
Class LinkedList {private: Node * root; public: … ~LinkedList(); };
LinkedList A; A.add(2); A.add(5); A.add(10); A.add(15); A.add(8);
root
A
2 5 8 10 15
• A goes out of scope. What Happens?
• When destructor is called, what is deleted?
• What Happens to this memory area?
• It is garbage!
• Destructor must also delete this area.
~LINKEDLIST()
~LinkedList()
{
Node *temp1, *temp2;
temp1 = root;
while (temp1 != NULL)
{
temp2 = temp1->next;
delete temp1;
temp1 = temp2;
}
}
root
A
2 5 8 10 15
temp1 temp2
