What are Linked Lists

 A linked list is a linear data

structure.
 Nodes make up linked lists.
 Nodes are structures made up
of data and a pointer to another
node.
 Usually the pointer is called
next.
 Arrays Vs Linked Lists
Arrays Linked list

Fixed size: Resizing is expensive Dynamic size

Insertions and Deletions are inefficient: Insertions and Deletions are efficient: No
Elements are usually shifted shifting

Random access i.e., efficient indexing No random access

 Not suitable for operations requiring
accessing elements by index such as sorting

No memory waste if the array is full or almost Since memory is allocated dynamically(acc. to
full; otherwise may result in much memory our need) there is no waste of memory.
waste.

Sequential access is faster [Reason: Elements in Sequential access is slow [Reason: Elements not
contiguous memory locations] in contiguous memory locations]
Types of lists
 There are two basic typesof linked list

 Singly Linked list

 Doubly linked list

Singly Linked List
 Each node has only one link part

 Each link part contains the address of the next node in

the list

 Link part of the last node contains NULL value which

signifies the end of thenode
 Schematic representation
 Here is a singly-linked list(SLL):

myList

a b c d

•Each node contains a value(data) and a pointer

to the next node in thelist

• myList is the header pointer which points at

the first node in thelist
Basic Operations on a list

• Creating a List
• Inserting an element in alist
• Deleting anelement from a list
• Searching a list
• Reversing a list
Creating a node

struct node{
int data; // A simple node of a linked list
node*next;
}*start; //start points at the firstnode
start=NULL ; initialised to NULL at beginning
node* create( int num) //say num=1 is passed frommain
{
node*ptr;
ptr= new node; //memory allocateddynamically
if(ptr==NULL)
‘OVERFLOW’ // no memoryavailable
exit(1);
else
{
ptr->data=num;
ptr->next=NULL;
return ptr;
}
}
To be called from main() as:-

void main()
{
node* ptr;
int data;
cin>>data;
ptr=create(data);
}
Inserting the node in a SLL

There are 3 cases here:-

 Insertion at thebeginning
 Insertion at theend
 Insertion after a particular node
 Insertion at the beginning
There are two steps to be followed:-

a) Make the next pointer of the node point towards the

first node of the list

b) Make the start pointer point towards this new node

 If the list is empty simply make the start pointer

point towards the newnode;
void insert_beg(node* p)
{
node* temp;
if(start==NULL) //if the list is empty
{
start=p;
cout<<”\nNode inserted successfully at the
beginning”;
}
else {
temp=start;
start=p;
p->next=temp; //making new node point at
} the first node of thelist
}
Inserting at the end
Here we simply need to make the next pointer
of the last node point to the new node
void insert_end(node* p)
{
node *q=start;
if(start==NULL)
{
start=p;
cout<<”\nNode inserted successfully at theend…!!!\n”;
}
else{
while(q->link!=NULL)
q=q->link;
q->next=p;
}
}
Inserting after an element
Here we again need to do 2 steps :-

 Make the next pointer of the node to be inserted

point to the next node of the node after which you
want to insert the node

 Make the next pointer of the node after which the

node is to be inserted, point to the node to be
inserted
void insert_after(int c,node* p)
{
node* q;
q=start;
for(int i=1;i<c;i++)
{
q=q->link;
if(q==NULL)
cout<<”Less than “<<c<<” nodes in thelist…!!!”;
}
p->link=q->link;
q->link=p;
cout<<”\nNode inserted successfully”;
}
Deleting a node in SLL
Here also we have threecases:-

 Deleting the first node

Deleting the last node

Deleting the intermediate node

Deleting the first node
Here we apply 2 steps:-

 Making the start pointer point towards the 2nd

node

 Deleting the first node using deletekeyword

start

one two three

void del_first()
{
if(start==NULL)
cout<<”\nError……List is empty\n”;
else
{
node* temp=start;
start=temp->link;
delete temp;
cout<<”\nFirst node deleted successfully….!!!”;
}
}
Deleting the last node
Here we apply 2 steps:-

 Making the second last node’s next pointerpoint

to NULL

 Deleting the last node viadelete keyword

start

node1 node2 node3

void del_last()
{
if(start==NULL)
cout<<”\nError….List isempty”;
else
{
node* q=start;
while(q->link->link!=NULL)
q=q->link;
node* temp=q->link;
q->link=NULL;
delete temp;
cout<<”\nDeleted successfully…”;
}
}
}
Deleting a particular node
Here we make the next pointer of the node previous to
the node being deleted ,point to the successor node of
the node to be deleted and then delete the node using
delete keyword

node1 node2 node3

To be deleted
void del(intc)
{
node* q=start;
for(int i=2; i<c;i++)
{
q=q->link;
if(q==NULL)
cout<<”\nNode not found\n”;
}
if(i==c)
{
node* p=q->link; //node to bedeleted
q->link=p->link; //disconnecting the nodep
delete p;
cout<<“Deleted Successfully”;
}
}
Searching a SLL
 Searching involves finding the required element inthe
list
 We can use various techniques of searching like linear
search or binary search where binary search is more
efficient in case of Arrays
 But in case of linked list since random access is not
available it would become complex to do binary search
in it
 We can perform simple linear search traversal
In linear search each node is traversed till the data in
the node matches with the required value

void search(intx)
{
node*temp=start;
while(temp!=NULL)
{
if(temp->data==x)
{
cout<<“FOUND ”<<temp->data;
break;
}
temp=temp->next;
}
}
Reversing a linked list
• Wecan reverse a linked list by reversing the
direction of the links between 2 nodes
  We make use of 3 structure pointers say p,q,r

 At any instant q will point to the node next to p and r

will point to the node next to q

Head P p
q rq NULL

NULL

• For next iteration p=q andq=r

• At the end we will change head to the last node

 Code
void reverse()
{
node*p,*q,*r;
if(start==NULL)
{
cout<<"\nList is empty\n";
return;
}
p=start;
q=p->link;
p->link=NULL;
while(q!=NULL)
{
r=q->link;
q->link=p;
p=q;
q=r;
}
start=p;
cout<<"\nReversed successfully";
}
 COMPLEXITY OF VARIOUS OPERATIONS
IN ARRAYS AND SLL

Operation ID-Array Complexity Singly-linked list Complexity

Insert at beginning O(n) O(1)
Insert at end O(1) O(1) if the list has tail reference
O(n) if the list has no tail reference

Insert at middle O(n) O(n)

Delete at beginning O(n) O(1)
Delete at end O(1) O(n)
Delete at middle O(n): O(n):
O(1) access followed by O(n) O(n) search, followed by O(1) delete
shift
Search O(n) linear search O(n)
O(log n) Binary search

Indexing: What is O(1) O(n)

the element at a
given position k?
 Doubly Linked List
1. Doubly linked list is a linked data structure that consists of a set of
sequentially linked records called nodes.

2. Each node contains three fields::

-: one is data part which contain data only.
-:two other field is links part that are point
or references to the previous or to the next
node in the sequence of nodes.

3. The beginning and ending nodes' previous and next

links, respectively, point to some kind of terminator,
typically a sentinel node or null to facilitate traversal
of the list.
 NODE
previous data next

A B C
NULL 11 786 200 656 400 786 777 NULL

200 786 400

A doubly linked list contain three fields: an integer value, the

link to the next node, and the link to the previous node.
DLL’s compared to SLL’s

 Advantages:  Disadvantages:
 Can be traversed in either  Requires more space
direction (may be  List manipulations are
essential for some slower (because more
programs) links must bechanged)
 Some operations, suchas  Greater chance of having
deletion and inserting bugs (because more links
before a node, become must be manipulated)
easier
Structure of DLL
struct node
{
int data;
node*next;
node*previous; //holds the address of previousnode
};

previous. .Data .next

inf
Inserting at beginning
void insert_beg(node *p)
{
if(start==NULL)
{
start=p;
cout<<"\nNode inserted successfully at thebeginning\m";
}
else
{
node* temp=start;
start=p;
temp->previous=p; //making 1st node’s previous point to the
new node
p->next=temp; //making next of the new node point to the
1st node
cout<<"\nNode inserted successfully at thebeginning\n";
}
Inserting at the end
void insert_end(node* p)
{
if(start==NULL)
{
start=p;
cout<<"\nNode inserted successfully at the end";
}
else
{
node* temp=start;
while(temp->next!=NULL)
{
temp=temp->next;
}
temp->next=p;
p->previous=temp;
cout<<"\nNode inserted successfully at the end\n";
}
}
Inserting after a node

Making next and previous pointer of the node to be

inserted pointaccordingly

Adjusting the next and previous pointers of the nodes b/w which
the new nodeaccordingly
void insert_after(int c,node* p)
{
temp=start;
for(int i=1;i<c-1;i++)
{
temp=temp->next;
}
p->next=temp->next;
temp->next->previous=p;
temp->next=p;
p->previous=temp;
cout<<"\nInserted successfully";
}
Deleting a node
• Node deletion from a DLL involves changing twolinks
• In this example,wewill delete node b
myDLL

a b c

• We don’t have to do anything about the links in node b

• Garbage collection will take care of deletednodes
• Deletion of the first node or the last node is a special
case
void del_at(int c)
{
node*s=start;
{
for(int i=1;i<c-1;i++)
{
s=s->next;
}
node* p=s->next;
s->next=p->next;
p->next->previous=s;
delete p;
cout<<"\nNode number "<<c<<" deleted successfully";
}
}
}
Deletion at beginning
Algorithm
STEP 1: IF HEAD = NULL
WRITE UNDERFLOW
GOTO STEP 6

STEP 2: SET PTR = HEAD

STEP 3: SET HEAD = HEAD → NEXT
STEP 4: SET HEAD → PREV = NULL
STEP 5: FREE PTR
STEP 6: EXIT
 Deletion in doubly linked list at the end
•Step 1: IF HEAD = NULL
Write UNDERFLOW
Go to Step 7
[END OF IF]
•Step 2: SET TEMP = HEAD
•Step 3: REPEAT STEP 4 WHILE TEMP->NEXT != NULL
•Step 4: SET TEMP = TEMP->NEXT
[END OF LOOP]
•Step 5: SET TEMP ->PREV-> NEXT = NULL
•Step 6: FREE TEMP
•Step 7: EXIT
What is circular linked list?
• Circular linked list is a variation of linked list in
which the first elements points to the next
element and the last element points to the first
element.
• Both singly and doubly linked list can be made
into a circular linked list.
• Circular linked list can be used to help traverse
the same list again and again if needed.
Implementation: Instead of placing NULL at
the last node’s address field you are placing
the address of very first node.
Circular linked list vs. Linear linked list

• A circularly linked list may be a natural option to represent arrays

that are naturally circular, e.g. a pool of buffers that are used and
released in FIFO order, or a set of processes that should be time-
shared. In these applications, a pointer to any node serves as a
handle to the whole list.

• With a circular list, a pointer to the last node gives easy access also
to the first node, by following one link. Thus, in applications that
require access to both ends of the list, a circular structure allows one
to handle the structure by a single pointer, instead of two.

• The simplest representation for an empty circular list (when such a

thing makes sense) is a null pointer, indicating that the list has no
nodes. Without this choice, many algorithms have to test for this
special case, and handle it separately. By contrast, the use of null to
denote an empty linear list is more natural and often creates fewer
special cases.
Types of circular linked list:
1. Singly: The last node points to the first node and
there is only link between the nodes of linked list.
2. Doubly: The last node points to the first
node and there are two links between the
nodes of linked list.
Advantages of Circular linked lists:
1. Any node can be a starting point. We can traverse the whole list
by starting from any point. We just need to stop when the first
visited node is visited again.

2. Circular lists are useful in applications to repeatedly go around

the list. For example: when multiple applications are running on
a PC, it is common for the operating system to put the running
applications on a list and then to cycle through them, giving each
of them a slice of time to execute, and then making them wait
while the CPU is given to another application. It is convenient for
the operating system to use a circular list so that when it reaches
the end of the list it can cycle around to the front of the list.

3. Circular Doubly Linked Lists are used for implementation of

advanced data structures like Fibonacci Heap.
Disadvantages of Circular linked list
1. Depending on the implementation, inserting
at start of list would require doing a search for
last node which could be expensive.

2. Finding end of the list and loop control is

harder ( no NULL’s to mark the beginning and
end).
Operations on singly circular
linked list

• Insertion
• Deletion
• Display
 Insertion :
• Insertion can be of three types.
▫ Insert at first
▫ Insert at last
▫ Insert after constant

• Note: insertion after constant in circular

and linear linked list is exact same .
Insertion into circular singly linked list at beginning

if(head == NULL)
{
head = ptr;
ptr -> next = head;
}
temp = head;
while(temp->next != head)
temp = temp->next;
temp -> next = ptr;
ptr->next = head;
head = ptr;
Insertion into circular singly linked list
at the end

if(head == NULL)
{
head = ptr;
ptr -> next = head;
}
temp = head;
while(temp->next != head)
temp = temp->next;
temp -> next = ptr;
ptr -> next = head;
Deletion in circular singly linked list at
beginning
Scenario 1: (The list is Empty)

if(head == NULL)
{
printf("\nUNDERFLOW");
return;
}

Scenario 2: (The list contains single node)

if(head->next == head)
{
head = NULL;
}
Scenario 3: (The list contains more than one node)

ptr = head;
while(ptr -> next != head)
ptr = ptr -> next;
ptr->next = head->next;
head = ptr->next;
Deletion in Circular singly linked list at the end

Scenario 1 (the list is empty)

if(head == NULL)
{
printf("\nUNDERFLOW");
return;
}

Scenario 2(the list contains single element)

if(head->next == head)
{
head = NULL;
}
Scenario 3(the list contains more than one element)

ptr = head;
while(ptr ->next != head)
{
preptr=ptr;
ptr = ptr->next;
}
preptr->next = ptr -> next;
Insertion in circular doubly linked list at
beginning
if(head == NULL)
{
head = ptr;
ptr -> next = head;
ptr -> prev = head;
}
temp = head;
while(temp -> next != head)
{
temp = temp -> next;
}
temp -> next = ptr;
ptr -> prev = temp;
head -> prev = ptr;
ptr -> next = head;
head = ptr;
Insertion in circular doubly linked list at
end
if(head == NULL)
{
head = ptr;
ptr -> next = head;
ptr -> prev = head;
}
temp = head;
while(temp->next != head)
temp = temp->next;
head -> prev = ptr;
ptr -> next = head;
temp->next = ptr;
ptr ->prev=temp;
Deletion in Circular doubly linked list at
beginning
Scenario 1 (the list is empty)

if(head == NULL)
{
printf("\nUNDERFLOW");
return;
}

Scenario 2(the list contains single element)

if(head->next == head)
{
head = NULL;
}
Scenario 3(the list contains more than
one element)
temp = head;
while(temp -> next != head)
{
temp = temp -> next;
}

temp -> next = head -> next;

head -> next -> prev = temp;

head = temp -> next;

Deletion in circular doubly linked list at
end
Scenario 1 (the list is empty)

if(head == NULL)
{
printf("\nUNDERFLOW");
return;
}

Scenario 2(the list contains single element)

if(head->next == head)
{
head = NULL;

}
Scenario 3 (the list contains more than
one element)

temp = head;
while(temp -> next != head)
{
temp = temp -> next;
}
temp -> prev -> next = head;
head -> prev = temp -> prev;
APPLICATIONS OF LINKED LIST
1.Applications that have an MRU list (a linked list of file
names)

2.The cache in your browser that allows you to hit the BACK
button (a linked list of URLs)

3.Undo functionality in Photoshop or Word (a linked list of

state)

4.A stack, hash table, and binary tree can be implemented

using a doubly linked list.
• Polynomials
•Array Implementation:
• p1(x) = 8x3 + 3x2 + 2x + 6
• p2(x) = 23x4 + 18x - 3
p1(x) p2(x)

6 2 3 8 -3 18 0 0 23
0 2 0 2 4

Index
represents
exponents
•This is why arrays aren’t good to represent
polynomials:

• p3(x) = 16x21 - 3x5 + 2x +6

6 2 0 0 -3 0 ………… 0 16

WASTE OF SPACE!
• Advantages of using an Array:

• only good for non-sparsepolynomials.

• ease of storage and retrieval.

• Disadvantages of using an Array:

• have to allocate array size ahead of time.

•huge array size required for sparse
polynomials. Waste of space andruntime.
 • Polynomial Representation

• Linked list Implementation:

• p1(x) = 23x9 + 18x7 + 41x6 + 163x4 + 3

• p2(x) = 4x6 + 10x4 + 12x + 8

P1 23 9 18 7 41 6 18 7 3 0

TAIL (contains pointer)

P2 4 6 10 4 12 1 8 0

NODE (contains coefficient & exponent)

• Advantages of using a Linked list:

•save space (don’t have to worry about sparse

polynomials) and easy tomaintain
•don’t need to allocate list size and can
declare nodes (terms) only asneeded

• Disadvantages of using a Linked list :

• can’t go backwards through thelist
•can’t jump to the beginning of the listfrom
the end.
 Polynomials
em 1 em 2 e0
A( x ) am 1 x am 2 x ... a 0 x
Representation

struct polynode {
int coef;
int exp;
struct polynode * next;
};
typedef struct polynode *polyptr;

coef exp next

•Adding polynomials using a Linked list
representation: (storing the result in p3)

Todo this, we have to break the process down to

cases:
• Case 1: exponent of p1 > exponent ofp2
• Copy node of p1 to end ofp3.
[go to next node]
• Case 2: exponent of p1 < exponent ofp2
• Copy node of p2 to end ofp3.
[go to next node]
• Case 3: exponent of p1 = exponent ofp2
•Create a new node in p3 with the same
exponent and with the sum of the
coefficients of p1 and p2.
Example
14
a 3x 2x 8
1
a
3 14 2 8 1 0 null

14 10
b 8x 3x 10 x 6
b
8 14 -3 10 10 6 null
Adding Polynomials
3 14 2 8 1 0
a
8 14 -3 10 10 6
b
11 14 a->expon == b->expon
d
3 14 2 8 1 0
a
8 14 -3 10 10 6
b
11 14 -3 10 a->expon < b->expon
3 14 2 8 1 0
a
8 14 -3 10 10 6
b
11 14 -3 10 2 8
d
a->expon > b->expon
THANK YOU