Data Structures and

Algorithms
Mr. Tahir Iqbal
[email protected]

Lecture 03: Link List

Tahir Iqbal, Department of Computer Sciences, BULC

Definition - List
• A list is a collection of items that has a particular order
• It can have an arbitrary length
• Objects / elements can be inserted or removed at arbitrary locations in the
list
• A list can be traversed in order one item at a time

Tahir Iqbal, Department of Computer Sciences, BULC

List Overview
• Linked lists
• Abstract data type (ADT)
• Basic operations of linked lists
• Insert, find, delete, print, etc.
• Variations of linked lists
• Singly linked lists
• Circular linked lists
• Doubly linked lists
• Circular doubly linked list

Tahir Iqbal, Department of Computer Sciences, BULC

Linked List Terminologies
• Traversal of List
• Means to visit every element or node in the list beginning from first to last.
• Predecessor and Successor
• In the list of elements, for any location n, (n-1) is predecessor and (n+1) is
successor.
• In other words, for any location n in the list, the left element is predecessor
and the right element is successor.
• Also, the first element does not have predecessor and the last element does
not have successor.

Tahir Iqbal, Department of Computer Sciences, BULC

Linked Lists

A B C 

Head

• A linked list is a series of connected nodes

• Each node contains at least
• A piece of data (any type)
• Pointer to the next node in the list
• Head: pointer to the first node
• The last node points to NULL
node
A

data pointer
Tahir Iqbal, Department of Computer Sciences, BULC
Lists – Another perspective
A list is a linear collection of varying length of
homogeneous components.

Homogeneous: All components are of the same

type.

Linear: Components are ordered in a line (hence

called Linear linked lists).

Arrays are lists..

Tahir Iqbal, Department of Computer Sciences, BULC
Arrays Vs Lists
• Arrays are lists that have a fixed size in memory.
• The programmer must keep track of the length of the
array
• No matter how many elements of the array are used
in a program, the array has the same amount of
allocated space.
• Array elements are stored in successive memory
locations. Also, order of elements stored in array is
same logically and physically.

Tahir Iqbal, Department of Computer Sciences, BULC

Arrays Vs Lists
• A linked list takes up only as much space in memory
as is needed for the length of the list.
• The list expands or contracts as you add or delete
elements.
• In linked list the elements are not stored in successive
memory location
• Elements can be added to (or deleted from) either end,
or added to (or deleted from)the middle of the list.

Tahir Iqbal, Department of Computer Sciences, BULC

Array versus Linked Lists
• Linked lists are more complex to code and manage than
arrays, but they have some distinct advantages.
• Dynamic: a linked list can easily grow and shrink in size.
• We don’t need to know how many nodes will be in the list. They are
created in memory as needed.
• In contrast, the size of a C++ array is fixed at compilation time.
• Easy and fast insertions and deletions
• To insert or delete an element in an array, we need to copy to
temporary variables to make room for new elements or close the gap
caused by deleted elements.
• With a linked list, no need to move other nodes. Only need to reset
some pointers.

Tahir Iqbal, Department of Computer Sciences, BULC

An Array A Linked List

Tahir Iqbal, Department of Computer Sciences, BULC

Basic Operations of Linked List
• Operations of Linked List
• IsEmpty: determine whether or not the list is empty
• InsertNode: insert a new node at a particular position
• FindNode: find a node with a given value
• DeleteNode: delete a node with a given value
• DisplayList: print all the nodes in the list

Tahir Iqbal, Department of Computer Sciences, BULC

An integer linked list
First Node of List Last Node of List

list
10 13 5 2

data next NULL

Tahir Iqbal, Department of Computer Sciences, BULC

Creating a List node
struct Node {
int data; // data in node
Node *next; // Pointer to next node
};

Node *p;
p = new Node;
p - > data = 10;
p - > next = NULL;

p 10

Tahir Iqbal, Department of Computer Sciences, BULC

The NULL pointer
NULL is a special pointer value that does not reference
any memory cell.

If a pointer is not currently in use, it should be set to

NULL so that one can determine that it is not pointing
to a valid address:

int *p;
p = NULL;

Tahir Iqbal, Department of Computer Sciences, BULC

Adding a node to a list
Node *p, *q;
p 10
p = new Node;
p - > data = 10;
p - > next = NULL;

q = new Node; q 6
q - > data = 6;
q - > next = NULL;

p - > next = q; p 10 6

q
Tahir Iqbal, Department of Computer Sciences, BULC
Accessing List Data
Node 1 Node 2

p 10 6

Expression Value
p Pointer to first node (head)
p - > data 10
p - > next Pointer to next node
p - > next - > data 6
p - > next - > next NULL pointer

Tahir Iqbal, Department of Computer Sciences, BULC

Linked List
struct List{ void delete(){
int item; Node * temp = head;
List * next; if (head == NULL){
}; return;
}
List * head = NULL; else{
head = head->next;
void insert(int x){ delete temp;
List * temp = new List; }
temp->item = x; }
if (head== NULL){
temp->next = NULL; void main(){
head = temp; insert(10);
} insert (20);
else{ insert (40);
temp->next=head; delete();
head = temp; }
}
} Tahir Iqbal, Department of Computer Sciences, BULC
Building a list from 1 to n
struct Node {
int data;
Node *next;
};

Node *head = NULL; // pointer to the list head

Node *lastNodePtr = NULL; // pointer to last node in list

head lastNodePtr

Tahir Iqbal, Department of Computer Sciences, BULC

Creating the first node

Node *ptr; // declare a pointer to Node

ptr = new Node; // create a new Node
ptr - > data = 1;
ptr - > next = NULL;

head = ptr; // new node is first

lastNodePtr = ptr; // and last node in list

head 1
ptr

lastNodePtr
Tahir Iqbal, Department of Computer Sciences, BULC
Adding more nodes
for (int i = 2; i < = n; i ++ ) {
ptr = new Node; //create new node
ptr - > data = i;
ptr - > next = NULL;
lastNodePtr - > next = ptr; // order is
lastNodePtr = ptr; // important
}

head 1 2
ptr

lastNodePtr
Tahir Iqbal, Department of Computer Sciences, BULC
Initially
head 1 2
ptr

lastNodePtr

head 1 2

lastNodePtr

ptr 3

•Create a new node with data field set to 3

•Its next pointer should point to NULL

Tahir Iqbal, Department of Computer Sciences, BULC

 head 1 2
ptr

lastNodePtr

head 1 2

lastNodePtr

ptr 3

•The next pointer of the node which was previously

last should now point to newly created node
“lastNodePtr->next=ptr”

Tahir Iqbal, Department of Computer Sciences, BULC

 head 1 2
ptr

lastNodePtr

head 1 2

lastNodePtr

ptr 3

•The next pointer of the node which was previously

last should now point to newly created node
“lastNodePtr->next=ptr”
•LastNodePtr should now point to the newly
created Node “lastNodePtr
Tahir Iqbal, Department of Computer Sciences, BULC
= ptr;”
 head 1 2
ptr

lastNodePtr

head 1 2

lastNodePtr

ptr 3

•LastNodePtr should now point to the newly

created Node “lastNodePtr = ptr;”

Tahir Iqbal, Department of Computer Sciences, BULC

Re-arranging the view

head 1 2 3
ptr
lastNodePtr

The items in this list are arranged in the form of Queue.

Tahir Iqbal, Department of Computer Sciences, BULC

Deleting a Node from end of list
if(head != NULL)
head = head - > next;

Tahir Iqbal, Department of Computer Sciences, BULC

Queue
struct Queue{ void Enqueue(int x){
int data; Queue * newNode = new Queue;
Queue * next; newNode->data = x;
} newNode->next = NULL;
Queue * front=NULL; if(rear == NULL){
Queue * rear=NULL; front = rear = newNode;
void main(){
// switch statement }
Enqueue(10); else{
rear->next = newNode;
Enqueue(23);
rear = newNode;
Enqueue(33);
}
Dequeue();
}
}

Tahir Iqbal, Department of Computer Sciences, BULC

Queue void Dequeue(){
Queue * temp = first;
if(front == NULL){
cout<<"Queue Empty";
}
elseif(front == rear){
cout<<"Item deleted";
front = rear = NULL;
delete temp;
}
else{
cout<<"Item deleted";
front = front->next;
delete temp;
}

Tahir Iqbal, Department of Computer Sciences, BULC

Traversing through the list
Node * currNode;
currNode = head;
while (currNode != NULL)
{
cout<< currNode->data;
currNode = currNode->next;
}

Tahir Iqbal, Department of Computer Sciences, BULC

Inserting a node in a list
head 2 5 8

prevNode currNode

6 ?
ptr
Determine where you want to insert a node. Suppose we
want to insert in ascending order.
Create a new node:
Node *ptr;
ptr = new Node;
ptr - > data = 6;
Tahir Iqbal, Department of Computer Sciences, BULC
Node *ptr, *currNode, *prevNode ;
prevNode = head;
ptr = new Node;
ptr->data = 6;
ptr->next = NULL;
currNode = head->next;
while (currNode->data < ptr->data)
{
prevNode = currNode;
currNode = currNode->next;
}

Note:
when this loop terminates prevNode and currNode are at a
place where insertion will take place. Only the “LINKS” or
pointers of the list need
Tahir Iqbal,to be adjusted
Department in case
of Computer Sciences, BULC of insert.
List after node insert
Now The new link has been added in the linked list

head 2 5 8

6
prevNode ptr
currNode

In this implementation we have used two temporary

pointers during insert procedure. Can we insert a node
using only one pointer!

Tahir Iqbal, Department of Computer Sciences, BULC

Deleting a node from a list
head 2 5 8

prevNode delNode
Step 1: Use a pointer that traverse through the list and finds the
previous node of the desired node to be deleted.

prevNode - > next = delNode - > next;

head 2 5 8

prevNode
Tahir Iqbal, Department ofdelNode
Computer Sciences, BULC
Finishing the deletion
Step 2: Remove the pointer from the deleted link.

delNode - > next = NULL;

head 2 5 8

prevNodePtr delNode

Step 3: Free up the memory used for the deleted node:

delete delNode;
Tahir Iqbal, Department of Computer Sciences, BULC
List Operations - Summarized

Tahir Iqbal, Department of Computer Sciences, BULC

Traversing a Linked List

Tahir Iqbal, Department of Computer Sciences, BULC

Insertion in a Linked List

Tahir Iqbal, Department of Computer Sciences, BULC

Deletion from a Linked List

Tahir Iqbal, Department of Computer Sciences, BULC