Data Structures

S. Y. B. Tech CSE Semester – III

DEPARTMENT OF COMPUTER ENGINEERING & TECHNOLOGY

 Syllabus
UNIT 4
Linked List: Linked List as an Abstract Data Type, Representation of Linked List Using
Sequential Organization, Representation of Linked List Using Dynamic Organization,
Types of Linked List: singly linked, Circular Linked Lists, Doubly Linked List, Doubly
Circular Linked List, Primitive Operations on Linked List, Polynomial Manipulations-
Polynomial addition. Generalized Linked List (GLL) concept, Representation of
Polynomial using GLL.
Case Study : Garbage Collection

DATA STRUCTURE -I UNIT-I 2

 Linked List
Topics to be Covered
• Linked List as an ADT

• Representation of Linked List Using Sequential Organization

• Representation of Linked List Using Dynamic Organization

• Operations on Linked List

• Polynomial operations using linked list

• Circular Linked List, Doubly Linked List , Generalized Linked List (GLL)

Case Study : Garbage Collection

DATA STRUCTURE -I UNIT-IV

 Types of Data Structures

DATA STRUCTURE

LINEAR
NONLINEAR

ARRAY
LINKLIST STACK
QUEUE TREES & GRAPH
 Linked List ADT
structure Linked List (item)
declare CREATE() -> Linked list
insert(item, linked list) -> linked list
delete(linked list) -> linked list
ISEMPS(linked list) -> boolean;
for all L ∈ Linked list, i ∈ item let
ISEMPS(CREATE) ::= true
ISEMPS(insert(i,L)) ::= false
delete(CREATE) ::= error
delete(insert(I,L)) ::= L
end Linked List
 Introduction to linked list
• Representation of simple data structures using an array and a sequential mapping
are studied.

• These representations had the property that successive nodes of the data object
were stored fixed distance apart.

• If the element aij of a table was stored at location Lij, then a i, j+1 was at the location
L ij + c for some constant c;

(BAT, CAT, EAT, FAT, HAT, JAT, LAT, MAT, OAT, PAT, RAT, SAT, TAT, VAT,
WAT)

• Disadvantage of a sequential mapping for ordered lists

– insertion and deletion of arbitrary elements become expensive.(Add word
GAT will require shifting)
 contd…
• Solution to this problem of data movement in sequential representations
is achieved by using linked representations .

• Unlike a sequential representation where successive items of a list are

located a fixed distance apart, in a linked representation these items may
be placed anywhere in memory.

• Another way of saying this is that in a sequential representation the order

of elements is the same as in the ordered list, while in a linked
representation these two sequences need not be the same.
 contd…
• To access elements in the list in the correct order, with each element we
store the address or location of the next element in that list.

• Thus, associated with each data item in a linked representation is a pointer

to the next element.

• This pointer is often referred to as a link.

• In general, a node is a collection of data, DATA1, ..., DATAn and links

LINK1, ...,LINKm. Each item in a node is called a field. A field contains
either a data item or a link.
 Linked lists
• Linked lists are appropriate when the number of data elements
to be represented in the data structure at once is unpredictable.

• Linked lists are dynamic, so the length of a list can increase or

decrease as necessary.

• Each node does not necessarily follow the previous one

physically in the memory.

• Linked lists can be maintained in sorted order by inserting or

deleting an element at the proper point in the list.
 What is Linked List?
• A linked list is an ordered collection of finite homogeneous data
elements called nodes where the linear order is maintained by means
of links or pointers.

Pointer to the
first node

Info/Data Link Field/

field Address Field
 Anatomy of a linked list
• A linked list consists of:
– A sequence of nodes

myList

a b c d

Each node contains a value

and a link (pointer or reference) to some other node

The last node contains a null link

The list may (or may not) have a header

 More terminology
• A node’s successor is the next node in the sequence
– The last node has no successor

• A node’s predecessor is the previous node in the sequence

– The first node has no predecessor

• A list’s length is the number of elements in it

– A list may be empty (contain no elements)
 Realization of Linked List Using Arrays

• Let L ={Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec}

• L is an ordered set

• List is stored in Data -1D array

• Elements are not stored in the same order as in the set L.

• To maintain the sequence ,second array ,Link is added

• List starts at 10th Loc
 Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec

Data Index Link

Jun 1 4
Sep 2 7
Feb 3 8
Jul 4 12
5
Dec 6 -1
Oct 7 14
Mar 8 9
Apr 9 11
Head Jan 10 3
May 11 1
Aug 12 2
13
Nov 14 6
15
 Dynamic memory management
• In which memory resources are allocated whenever they are
needed, and freed whenever they are not necessary anymore

• Linked lists, are defined precisely in such a way as to allow

for dynamically allocating and deallocating memory,
depending on the requirements of the application.

• Syntax of malloc() in C
• ptr = (cast-type*) malloc(byte-size)
 Pointers in C

• Declare Pointer P of type integer: int *P;

• Allocate memory and assign its address to P:

P = (int *) malloc ( sizeof ( int ) );
• Store value 10 in the allocated memory:

P 10
*P = 10;

Notes:
1. The new allocated memory is anonymous ( i.e. does not
have a name of its own
2. The only way we can access this location is via P.
 Pointers in C – Dynamic Memory Allocation

• But what does this complicated line do?:

P = (int *) malloc ( sizeof ( int ) ); Read This
First !!!

int Sizeof( int ): 1

But, what is this void * 3 A function that takes a primitive
in front of malloc? data type like int, float, char, etc.
Well, we do not know and just return its size in bytes!
what type of address to
void * malloc( int ): 2
return until we use
malloc in our programs!! A function that takes a number
So, that’s why we cast of bytes, and dynamically allocate
void * to int * memory of that size in bytes,
in this example, since P is and finally returns its address!
declared of type (in this case to P)
int* .
 Types of linked lists
• The number of pointers are maintained depending on the
requirements and usage

• Based on this ,linked list are classified into three categories.

– Singly linked lists
– Circular linked lists
– Doubly linked lists
 Empty List
• Empty Linked list is a single pointer having the value
of NULL.

head = NULL;

head
 Singly Linked List
A linked list in which each node contains only one link
field pointing to the next node in the list

--- 05 60 99

Head Node First data

Node

First node is called the header node where no data

element is stored, but the link field holds the address of
the node containing very first data element.
 Doubly Linked List
•A doubly linked list is a linear data structure in which each
node can have any number of data fields and two link fields
which are used to point to the previous node and the next
node.

--- 05 60 99

Head Node First data

Node
 Circular Linked List
A linked list where the last node points to the header node
is called a circular linked list.
There are no NULL links.

--- 05 60 99

Head Node First data

Node
 Circular Doubly Linked
List
A Doubly linked list where the last node points to the
header node and Header node Points to last node is called
a circular Doubly linked list.
There are no NULL links.

--- 05 60 99

Head Node First data

Node
 Basic Operations on a list
• Creating a List
• List Traversal
• Inserting an element in a list
• Deleting an element from a list
• Searching a list
• Reversing a list
• Merging two linked lists into a larger list
 Data Structure of Node
struct node
{
int data; data Next
(Address of
struct node *next; next node)
};
struct node *head;
 Creation of SLL
head=(struct node *)malloc(sizeof(struct node));
head->next=NULL;

//Creation of Link List

Algorithm create(*H)
{
temp=H;
repeat untill choice =‘y’
{
allocate memory to curr;
accept curr->data;
curr->next=NULL;
temp->next=curr;
temp=curr; //temp=temp->next
Read choice;
}
}
Display Link List Finding length of Link List
Algorithm display(*H)
Algorithm len(*H)
{
if H->next ==NULL {
Print “ list is empty “ curr=H->next;
else while(curr!=NULL)
{ {
//print head node values
i++;
curr=H->next;
while(curr!=NULL) curr=curr->next;
{ }
Print curr,curr->data,curr->next; return(i);
curr=curr->next; }
}
}
 Insertion in a linked list
a b
… …
4. 3.
curr
2.Accept
nnode Data

1.Allocate memory

1.Allocate memory for nnode ;

2.Accept data for nnode;
3.nnode->next = curr->next;
4.curr->next = nnode;

28
 Insert a new node by position

Algorithm Insertbypos(*H)
{
i=1 ; curr=H;
//allocate memory for nnode node;
read nnode->data and pos; //accept data & position to be inserted:
k=len();
If(pos>k+1)
//Print “Data can't be inserted”;
else
{
while(curr!=NULL && i<pos)
{
i++;
curr=curr->next;
}
nnode->next=curr->next;
curr->next=nnode;
}
 Deletion from a linked list

… a x b
…
deletedNode
current

Node *deletedNode = current->next;

current->next = current->next->next;
delete deletedNode;
 Delete a node by position
Algorithm delpos(*H) while(ctr<pos && curr!=NULL)
{ {
prev=H; ctr=1; ctr++;
curr=H->next; prev=curr;
read pos; curr=curr->next;
//Accept position of data to be deleted: }
temp=curr;
k=len(); prev->next=curr->next;
if (k<pos) curr->next=NULL;
//display Data can't be deleted; free(temp);
else }
{ }
Reverse of Linked List(Using Pointers)

Algorithm reverse(*H)
{
prev=NULL;
curr=head->next;
while(curr!=NULL)
{
future=curr->next;
curr->next=prev;
prev=curr;
curr=future;
}
head->next=prev;
}
 Sorting of SLL by using pointers
Algorithm sort(*H) if(curr->data > temp->data
{ {
len=len(H); prev->next=temp;
curr->next=temp->next;
for i=1 to len-1
temp->next=curr;
{
prev=temp;
prev=H; }
curr=H->next; else
for j=0 to <l-i {
{ prev=curr;
temp=curr->next; curr=curr->next;
}
} //end for inner for
} //end for outer for
} //end Algorithm
 Merging of SLL by using pointers
Algorithm merge(*H1,*H2) else
{ {
curr1=H1->next;
temp->next=curr2;
curr2=H2->next;
if(curr1->data<curr2->data) temp=curr2;
{ curr2=curr2->next;
temp=head1; }
flag=1;
} }
else if(curr1==NULL)
{ temp->next=curr2;
temp=head2;
flag=0;
if(curr2==NULL)
} temp->next=curr1;
while(curr1!=NULL && curr2!=NULL) if(flag==1)
{
display(head1);
if(curr1->data<curr2->data)
{ else
temp->next=curr1; display(head2);
temp=curr1; }
curr1=curr1->next;
 Arrays Vs Linked Lists
Arrays Linked list

Fixed size: Resizing is expensive Dynamic size

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

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]
 Doubly-Linked Lists
▪ It is a way of going both directions in a linked list, forward and reverse.
▪ Many applications require a quick access to the predecessor node of
some node in list.
A node in a doubly-linked list store two references:
•A next link; that points to the next node in the list, and
•A prev link; that points to the previous node in the list.
Advantages:
Convenient to traverse the list backwards.
Simplifies insertion and deletion because you no longer have to refer to the
previous node.
Disadvantage:
Increase in space requirements.
pre nex
v t

ele nod
m e
 Doubly Link List creation
Algorithm Create(*H)
{
struct node temp=H;
{ repeat till choice =y
char data[20]; {
node *next,*prev; //allocate memory for new
}; node //in curr pointer
temp->next=curr;
curr->prev=temp;
curr->next=NULL;
temp=curr;
}
Read choice;
}
 Insertion
head current

newNode = allocate newNode(x);

newNode->prev = current; newNode
newNode->next = current->next;
newNode->prev->next = newNode;
newNode->next->prev = newNode;
current = newNode;
 Deletion
head current

oldNode = current;
oldNode->prev->next = oldNode->next;
oldNode->next->prev = oldNode->prev;
delete oldNode;
current = head;
Circular Linked Lists
Allocation of memory for head node using constructor

head=(struct node *)malloc(sizeof(struct node));

head->next=head;

//Creation of Link List

Algorithm create(*H)
{ temp=H;
repeat until choice =‘y’ {
allocate memory to curr;
accept curr->data;
curr->next=H;
temp->next=curr;
temp=curr; //temp=temp->next
Read choice;
}
}
 Advantages over Singly-linked Lists
• Quick update operations:
such as: insertions, deletions at both ends (head
and tail), and also at the middle of the list.
• A node in a doubly-linked list store two
references:
• A next link; that points to the next node in the list,
and
• A prev link; that points to the previous node in the
list.
 DLLs compared to SLLs
• Advantages: • Disadvantages:
– Can be traversed in either – Requires more space
direction (may be – List manipulations are
essential for some slower (because more
applications) links must be changed)
– Some operations, such as – Greater chance of having
deletion and inserting bugs (because more links
before a node, become must be manipulated)
easier
 • Polynomial
•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
 • Polynomial (continued)

•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!
 • Polynomial (continued)

• Advantages of using an Array:

• only good for non-sparse polynomials.

• 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 and runtime.
 • Polynomial (continued)

• Linked list Implementation:

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

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

P1 23 9 18 7 41 6 163 4 3 0

TAIL (contains pointer)

P2 4 6 10 4 12 1 8 0

NODE (contains coefficient & exponent)

 Revisit Polynomials

coeff exp

a.first 3 1 2 8 1 0 0
4

1 1 1
b.first 8 -3 6 **
4 0 0
 Node structure of Polynomial
struct polyNode
{
// All members in “struct” are public
int coef; // coefficient
int exp; // exponent
struct polyNode *next;
};
 Addition of Two Polynomials (1)
• It is an easy way to represent a polynomial by
a linked list.
• Example of adding two polynomials a and b

a.first 3 14 2 8 1 0 0

b.first 8 14 -3 1 10 6 0
0
q
c.first 1 1 0 (i) p->exp == q->exp
1 4
 Addition of Two Polynomials (2)

a.first 3 14 2 8 1 0 0

b.first 8 14 -3 1 10 6 0
0
q

c.first 1 1 -3 1 0
1 4 0

(ii) p->exp < q->exp

 Addition of Two Polynomials (3)

a.first 3 14 2 8 1 0 0

b.first 8 14 -3 1 10 6 0
0

q
c.first 1 1 -3 1 2 8 0
1 4 0

(iii) p->exp > q->exp

4-52
 • Polynomial (continued)

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

p3)

To do this, we have to break the process down to cases:

• Case 1: exponent of p1 > exponent of p2

• Copy node of p1 to end of p3.
[go to next node]

• Case 2: exponent of p1 < exponent of p2

• Copy node of p2 to end of p3.
[go to next node]

•Case 3: exponent of p1 = exponent of p2

• Create a new node in p3 with the same exponent and with the sum of the
coefficients of p1 and p2.
 Addition of Polynomial
• Allocate the memory space for head;
• Head->exp=-1

Algorithm add(*H1,*H2)
{
Allocate a memory for H3;
head3->exp=-1;
t3=H3;
t1=H1->next;
t2=H2->next;
while(t1->exp!=-1||t2->exp!=-1)
{
if(t1->exp==t2->exp)
{
Allocate the memory for temp;
Add t1 coeff and t2 coeff in t3 coeff
copy one of the exponent in t3 exp
t3->next=temp;
temp->next=head3;
t3=temp;
Move t1 to next node ;
Move t2 to next node
}
 Addition of Polynomial
else
if exponent of p1 < exponent of p2
Copy node of p2 to end of p3.
else //exponent of p1 > exponent of p2
Copy node of p1 to end of p3

}//end of while

} //end algorithm
 Evaluation of Polynomial
Algorithm eval(*H, x)
{
cur=H->next;
while not end of list
{
using value of x find the sum of terms;
move cur to next node ;
}
print sum;
}
 Doubly Circular Linked
List
A Doubly linked list where the last node points to the
header node and Header node Points to last node is called
a circular Doubly linked list.
There are no NULL links.

--- 05 60 99

Head Node First data

Node
 Basic Operations on DCLL
• Create
• Display in forward and backward direction
• Delete a Node
• Add a Node
 Creating DCLL
struct node Algorithm_CreateCDLL(head)
{ {
int data; temp=head;
struct node *next,*prev; repeat if choice==’y’
};
{
curr=allocate memory;
Allocate memory to a head
node; accept curr data;
temp->next=curr;
head->next=head;
curr->prev=temp;
head->prev=head;
head->prev=curr;
curr->next=head
temp=curr;
}
 Display DCLL
Display_forward(Head) Display_backward(Head)
{ {
temp=head->next; temp=head->prev;
while(temp!=head) while(temp!=head)
{ {
print temp->data; print temp->data;
temp=temp->next; temp=temp->prev;
} }
 Adding a node in DCLL
AddanodeCDLL(head)
{ if(POS==len+1)//adding node at
len=lenCDLL(head); end
curr=allocate memory; {
accept curr->data; last=head->prev;
curr->next=curr->prev=NULL; last->next=curr;
ask user to enter position in POS curr->prev=last;
if(POS>len+1) curr->next=head;
print ‘not possible to add’ head->prev=curr;
if(POS<len) }
{
count=1
prevptr=head;
temp=head->next;
while(temp!=head && count!=POS)
{
prevptr=temp;
temp=temp->next;
}
prevptr->next=curr;
curr->next=temp;
temp->prev=curr;
curr->prev=prevptr;
}//end of if
 Deleting a node from DCLL
deleteanodeCDLL(head)
{
len=lenCDLL(head);
ask user to enter position of node to delete in POS
temp=head->next;
count=1;
while(temp!=head && Count!=POS)
{
prevptr=temp;
temp=temp->next;
}
prevptr->next=temp->next;
temp->next->prev=prevptr;
temp->next=temp->prev=NULL;
free(temp);
}
 Generalized Lists
• A generalized list, A, is a finite sequence of n ≥ 0
elements, a0, a1, a2, …, an-1, where ai, is either an atom or a
list. The elements ai,0 ≤ i ≤ n – 1, that are not atoms are
said to be the sublists of A.

• A list A is written as A = (a0, …, an-1 ), and the length of

the list is n.

• A list name is represented by a capital letter and an atom

is represented by a lowercase letter.

• a0 is the head of list A and the rest (a1, …, an-1) is the tail
of list A.
 Examples of Generalized Lists
• A = ( ): the null, or empty, list; its length is zero.

• B = (a, (b, c)): a list of length two; its first element is the atom
a, and its second element is the linear list (b, c).

• C = (B, B, ( )): A list of length three whose first two elements

are the list B, and the third element is the null list.

• D = (a, D): is a recursive list of length two; D corresponds to

the infinite list D = (a, (a, (a, …))).

• head(B) = ‘a’ and tail(B) = (b, c), head(tail(C))=B and

tail(tail(C)) = ( ).

• Lists may be shared by other lists.

• Lists may be recursive.

• It is a little surprising that every generalized
list can be represented using the node
structure
Tag=0/1 Data Link
• Tag=0 means data
• Tag = 1 means pointer to the sublist
 Representations of Generalized Lists

A=() Empty list

B=(a, (b,
B 0 a 1 0 c))

0 b 0 c 0

C 1 1 1 0 0 C=(B, B,
( ))
D 0 a 1 0 D=(a, D)
**
 GLL Examples
• L1=((A, B, C), ((D, E), F), G).

L2 = (a, (b), (c,d), e)

L3 = (a, ((b)), c).

 Polynomial Representation using
Generalized Linked List
Flag Variable, Coefficient Exponent nLink

•Flag = 0 variable is present

•Flag = 1 down pointer is present
•Flag = 2 coefficient and exponent is present
 General Polynomial

• P(x, y, z)=

• Rewritten as Cz2 + Dz, where C and D are

polynomials.
• Again, in C, it is of the form Ey3 + Fy2, where E and
F are polynomials.
• In general, every polynomial consists of a variable
plus coefficient-exponent pairs. Each coefficient
may be a constant or a polynomial.
• Suppose we need to devise a data representation for them and
consider one typical example, the polynomial P(x,y,z) =

• One can easily think of a sequential representation for P, say using

nodes with four fields: COEF, EXPX, EXPY, and EXPZ.
• But this would mean that polynomials in a different number of
variables would need a different number of fields, adding another
conceptual inelegance to other difficulties.
• These nodes would have to vary in size depending on the number
of variables, causing difficulties in storage management.
• The idea of using a general list structure with fixed size nodes arises
naturally if we consider re-writing
• P(x,y,z) as
 •Flag = 0 variable is present
9x5 + 7x4y + 10xz •Flag = 1 down pointer is present
•Flag = 2 coefficient and exponent is present
P(x, y) = 9x2y2 + 6xy2 + y + x2
P = y2(9x2 + 6x) + y + x2y0
 Garbage Collection
• After series of memory allocation and deallocation, there
are blocks of free memory scattered throughout the
available heap space

• To be able to reuse this memory, the memory allocator

will usually link the freed blocks together in a free list
by writing pointers to the next free block.

• Components of os ,memory management module,

maintain this list.
 Garbage collection contd..
• Os periodically collects all the free blocks and inserts into
the free pool.

• This is called as garbage collection.

• When CPU is idle, the garbage collection starts.

• It is invisible to programmer.
 Example
Obj Obj2 Obj3
hea 1
d
nex nex nex
t t t

• Assume programmer does the following

– obj1.next = obj2.next;

Obj Obj2 Obj3

hea 1
d
nex nex nex
t t t
 Example
• Now there is no way for programmer to
reference obj2
– it’s garbage
• In system without garbage collection this is
called a memory leak
– location can’t be used but can’t be reallocated
– waste of memory and can eventually crash a
program
• In system with garbage collection this
chunk will be found and reclaimed
• Mark Phase
When an object is created, its mark bit is set to 0(false).
• Set the marked bit for all the reachable objects (or the objects which a user
can refer to) to 1(true)

• Sweep Phase
As the name suggests it “sweeps” the unreachable objects
it clears the heap memory for all the unreachable objects.

• All those objects whose marked value is set to false are cleared from the heap
memory, for all other objects (reachable objects) the marked bit is set to false

• Mark value for all the reachable objects is set to false,

• Since we will run the algorithm (if required) and again we will go through the
mark phase to mark all the reachable objects.

77
 Example:
a) All the objects have their marked bits set to false.

78
 b) Reachable objects are marked true

79
 c) Non reachable objects are cleared from the heap.

80
 Mark-and-Sweep
• Basic idea
– go through all memory and mark every chunk
that is referenced
– make a second pass through memory and
remove all chunks not marked
OS 0 1 2 3

p2 = p2 =
650 360
0 10 35 45 60
0 0 0 0

•Mark chunks 0, 1, and 3 as marked

•Place chunk 2 on the free list (turn it into a
hole)