This document discusses linear data structures and linked lists. It begins with an introduction to data structures and defines them as a way to organize and store data and relationships between data. It then discusses list abstract data types (ADTs) and their operations. The document focuses on linked list representations of lists and covers singly linked lists, doubly linked lists, and circular linked lists. It describes the nodes that make up each type of linked list and their operations like insertion, deletion, and searching. Finally, it provides an example of using linked lists to represent polynomial equations and operations like addition on polynomials.

1. VELAMMAL ENGINEERING COLLEGE
An Autonomous Institution, Affiliated to Anna University Chennai, & Approved by AICTE Delhi
Department of Computer Science and
Engineering
UNIT 1 - LINEARDATASTRUCTURES–
LIST
Dr.M.Usha, AP

2. List ADT
Mrs. G. Sumathi
Assistant Professor
Velammal Engineering College
Chennai

3. Agenda
• Introduction to Data Structures
• List ADT
• Issues in Array Implementation
• Linked List Representation
• Types
• Applications of Linked List

4. Introduction to Data Structures
Data
Values or set of values
of different data types
such as int, float, etc.,
Way of organizing and
storing information so
that it is easy to use
Structure
Data + Structure
Way of organizing and
storing data on a computer
so that it can be used easily
and effectively

5. Introduction to Data Structures
Definition:
Data Structure is a way of organizing,
storing and retrieving data and their relationships
with each other

6. Classification of Data Structures
Data Structure
Primitive
int char float boolean
Non - Primitive
Linear
Array Linked List Stack Queue
Non - Linear
Tree Graph

7. • It is a type for objects whose behavior is defined by set of
values and set of operations from user point of view
• Mentions only what operations are to be performed but
not how they will be implemented
• Thus, ADT is the specification of a data type within some
language, independent of implementation
ADT – Abstract Data Type

8. Examples – List ADT, Stack ADT, Queue ADT, etc.,
Some operations on these ADT are:
List:
• insert(x)
• delete(x)
• find(x)
Stack:
• Push (x)
• Pop()
• isFull()
• isEmpty()
Queue:
• enqueue()
• dequeue()
• isFull()
• isEmpty()
ADT – Abstract Data Type

9. • List ADT can be represented in two ways
– Array
– Linked List
List ADT

10. • Collection of elements of same data type
• Elements in an array is stored in adjacent memory
location
Syntax:
• datatype arrayname [size]
• Eg: int a [50];
Operations:
• insertion()
• deletion()
• search()
Array ADT

11. • Fixed size: Resizing is expensive
• Requires continuous memory for allocation
– Difficult when array size is larger
• Insertions and deletions are inefficient
– Elements are usually shifted
• Wastage of memory space unless the array is
full
Issues in Array

12. • Linked list is a linear data structure
• Made up of chain of nodes
• Each node contains a data and a pointer to the next
node in the chain
• Last node of the list is pointed to NULL
Linked List ADT

13. • Each node contains two fields:
– Data field: Contains data element to be stored
– Pointer field: Contains the address of next node
Representation of Node in Linked List
Declaration of a node:
struct node
{
int data;
struct node *next;
};

14. • Singly linked list
• Doubly linked list
• Circular linked list
Types of Linked List

15. • Type of linked list
• Each node contains only one pointer field that
contains the address of the next node in the list
Singly Linked List (SLL)

16. Statement to create a node:
n= (struct node*) malloc(sizeof(sturct node))
Creating a Node
struct node
{
int data;
struct node *next;
} *n;

17. Major operations are:
• Insertion
– At the beginning
– At the middle
– At the end
• Deletion
– At the beginning
– At the middle
– At the end
• Search
Operations on Singly Linked List
Global declaration of a
Node:
struct node
{
int data;
struct node *next;
} *head, *tail, *n, *t;

18. Routine for Insertion at the Beginning
void ins_beg (int num) //Let num=10
{
n=(struct node *) malloc (size of(struct node));
nnext=NULL;
ndata=num;
if (head==NULL) //case 1
{
head=n;
tail=n;
}
else //case 2
{
nnext=head;
head=n;
}
}
10

19. Routine for Insertion at the End
void ins_end (int num) //Let num=10
{
n=(struct node *) malloc (size of(struct node));
nnext=NULL;
ndata=num;
if (head==NULL) //case 1
{
head=n;
tail=n;
}
else //case 2
{
tailnext=n;
tail=n;
}
}
10

20. Routine for Insertion at the Middle
void ins_end (int num, int mid_data) //Let num=10, mid_data=9
{
n=(struct node *) malloc (size of(struct node));
nnext=NULL;
ndata=num;
for(t=head; t!=NULL; t=tnext)
{
if(tdata==mid_data)
break;
}
nnext=tnext;
tnext=n;
}
10
83==9 ? NO 9==9 ? Yes
10
300
300
1500
300

21. Routine for Deletion at the Beginning
void del_beg ()
{
t=head;
head=tnext;
free(t);
}

22. Routine for Deletion at the End
void del_end ()
{
struct node *tp;
t=head;
while(tnext!=NULL)
{
tp=t;
t=tnext;
}
tail=tp;
tailnext=NULL;
free(t);
}

23. Routine for Deletion at the Middle
void del_mid (int num) //Let num=70
{
struct node *tp;
t=head;
while(tdata!=num)
{
tp=t;
t=tnext;
}
tpnext=tnext;
free(t);
}
2800
83!=70? Yes 9!=70? Yes 70!=70? No
1500

24. Routine for Search an Element
struct node* search (int num) //Let num=9
{
t=head;
while(t!=NULL && tdata!=num)
{
t=tnext;
}
return t;
}
t!=NULL? Yes
83!=9? Yes
t!=NULL? Yes
9!=9? No
Element Found!!

25. Linked List – Advantages & Disadvantages
Advantages:
• No wastage of memory
– Memory allocated and deallocated as per
requirement
• Efficient insertion and deletion operations
Disadvantages:
• Occupies more space than array to store a data
– Due to the need of a pointer to the next node
• Does not support random or direct access

26. Doubly Linked List (DLL)
• Type of linked list
• Each node contains two pointer fields that contains
the address of the next node and that of previous
node in the list

27. • Each node contains three fields:
– Data: Contains data element to be stored
– next: Contains the address of next node
– prev: Contains address of previous node
Representation of Node in DLL
Declaration of a node:
struct node
{
int data;
struct node *next, *prev;
};
A Node in DLL

28. Major operations are:
• Insertion
– At the beginning
– At the middle
– At the end
• Deletion
– At the beginning
– At the middle
– At the end
• Search
Operations on Doubly Linked List
Global declaration of a Node:
struct node
{
int data;
struct node *next, prev;
} *head, *tail, *n, *t;

29. Routine for Insertion at the Beginning
void ins_beg_dll (int num) //Let num=70
{
n=(struct node *) malloc(size of(struct node));
nnext=NULL;
nprev=NULL;
ndata=num;
if(head==NULL) //case 1
{
head=n;
tail=n;
}
else //case 2
{
nnext=head;
headprev=n;
head=n;
}
}
70
500
1000

30. void ins_end_dll (int num) //Let num=10
{
n=(struct node *) malloc (size of(struct node));
nnext=NULL;
nprev=NULL;
ndata=num;
if (head==NULL) //case 1
{
head=n;
tail=n;
}
else //case 2
{
tailnext=n;
nprev=tail;
tail=n;
}
}
Routine for Insertion at the End

31. void ins_end_dll (int num, int mid_data) //Let num=10, mid_data=9
{
n=(struct node *) malloc (size of(struct node));
nnext=NULL;
nprev=NULL;
ndata=num;
for(t=head; t!=NULL; t=tnext)
{
if(tdata==mid_data)
break;
}
nnext=tnext;
nprev=t;
tnextprev=n;
tnext=n;
}
Routine for Insertion at the Middle

32. void del_beg_dll ()
{
t=head;
head=headnext;
headprev=NULL;
free(t);
}
Routine for Deletion at the Beginning
t is freed

33. Routine for Deletion at the End
void del_end_dll ()
{
t=head;
while(tnext!=NULL)
{
t=tnext;
}
tail=tailprev;//tail=tprev;
tailnext=NULL;
free(t);
}

34. Routine for Deletion at the Middle
void del_mid_dll (int num) //Let num=9
{
t=head;
while(tdata!=num)
{
tp=t;
t=tnext;
}
tprevnext=tnext;
tnextprev=tprev;
free(t);
}

35. Routine for Search an Element
struct node* search_dll (int num) //Let num=9
{
t=head;
while(t!=NULL && tdata!=num)
{
t=tnext;
}
return t;
}
Element Found!!
t is returned

36. Advantages:
• Can traverse in both directions
• Operations in the middle of the list can be done
efficiently
– No need of extra pointer (tp) to track the previous
node
• Reversing the list is easy
Disadvantage:
• Space required to store a data is even more higher
than SLL
– Due to the use of two pointers
DLL – Advantages & Disadvantages

37. • Type of linked list
• The last node will be pointing to the first node
• It can be either singly or doubly linked
Circular Linked List (CLL)
Global declaration of a node:
struct node
{
int data;
struct node *next, *prev;
}*head,*n,*t;
100

38. Routine for Insertion at the Beginning
void ins_beg_cll (int num) //Let num=10
{
n=(struct node *) malloc (size of(struct node));
nnext=NULL;
ndata=num;
if (head==NULL) //case 1
{ head=n;
nnext=head;
}
else //case 2
{ t=head;
while(tnext!=head)
t=tnext;
tnext=n;
nnext=head;
head=n;
}
}
10
10 100

39. Routine for Insertion at the End
void ins_end_cll (int num) //Let num=10
{
n=(struct node *) malloc (size of(struct node));
nnext=NULL;
ndata=num;
t=head;
while(tnext!=head)
t=tnext;
tnext=n;
nnext=head;
}
10
1000

40. Routine for Insertion at the Middle
void ins_end_cll (int num, int mid_data) //Let num=10, mid_data=9
{
n=(struct node *) malloc (size of(struct node));
nnext=NULL;
ndata=num;
for(t=head; tnext!=head; t=tnext)
{
if(tdata==mid_data)
break;
}
nnext=tnext;
tnext=n;
}
10
1000

41. Routine for Deletion at the Beginning
void del_beg_cll ()
{
struct node *t1;
t=head;
t1=head;
while(tnext!=head)
t=tnext;
tnext=headnext;
head=tnext;
free(t1);
} 100
t1 is freed!!

42. Routine for Deletion at the End
void del_end_cll ()
{
struct node *tp;
t=head;
while(tnext!=head)
{
tp=t;
t=tnext;
}
tpnext=head;
free(t);
}
100
t is freed !!

43. Routine for Deletion at the Middle
void del_mid_cll (int num) //Let num=9
{
struct node *tp;
t=head;
while(tdata!=num)
{
tp=t;
t=tnext;
}
tpnext=tnext;
free(t);
} t is freed!!

44. Routine for Search
struct node* search_cll (int num) //Let num=9
{
t=head;
while(tnext!=head && tdata!=num)
{
t=tnext;
}
return t;
}

45. Advantage:
• Comparing to SLL, moving to any node from a node is
possible
Disadvantages:
• Reversing a list is complex compared to linear linked
list
• If proper care is not taken in managing the pointers,
it leads to infinite loop
• Moving to previous node is difficult, as it is needed
to complete an entire circle
CLL – Advantages & Disadvantages

46. Applications of List
Lists can be used to
• Sort elements
• Implement stack and queue
• Represent graph (adjacent list representation)
• Implement hash table
• Implement multiprocessing of applications
• Manipulate polynomial equations

47. Polynomial ADT
struct node
{
int coeff;
int pow;
struct node *next;
}*n;
Examples of polynomial equations:
– 9x5 + 7x3 – 4x2 + 8
7x4 – 17x3 – 8x2
To store the data of polynomial equations in the linked
list, each node contains two data fields, namely
coefficient and power and one next pointer field

48. Creating a Polynomial List
struct node* createpoly (int c, int p, struct node *t)
{
struct node *head, *tail;
head=t;
n=(struct node*) malloc(size of(struct node));
ncoeff=c;
npow=p;
nnext=NULL;
if (head==NULL)
{ head=n;
tail=n;
}
else
{ tailnext=n;
tail=n;
}
return head;
}

49. Polynomial Addition
Void addpoly (struct node *poly1, struct node *poly2, struct node *poly)
{
while(ploy1!=NULL && poly2!=NULL)
{
if(poly1pow>poly2pow)
{
polypow=ploy1pow;
polycoeff=poly1coeff;
ploy1=poly1next;
}
else if(poly1pow < poly2pow)
{
polypow=ploy2pow;
polycoeff=poly2coeff;
ploy2=poly2next;
}

50. else
{ polypow=ploy1pow;
polycoeff=poly1coeff + poly2coeff;
ploy1=poly1next;
ploy2=poly2next;
}
}
while(poly1 != NULL || poly2 != NULL)
{ if (poly1 != NULL)
{ polypow=ploy1pow;
polycoeff=poly1coeff;
ploy1=poly1next;
}
if (poly2 != NULL)
{ polypow=ploy2pow;
polycoeff=poly2coeff;
ploy2=poly2next;
}
}
}
Polynomial Addition Contd.,

51. Queries ??

52. Thank You!!!