SlideShare a Scribd company logo

"Array and Linked List in Data Structures with Types, Operations, Implementations, and Applications in C Programming"

Download as PPTX, PDF
U
usham61

Explains array and linked list concepts with types, operations, implementations in C, and real-time applications.

Engineering
Related topics:
Linked List Overview
1 of 50
Download to read offline
1
2
Most read
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
VELAMMAL ENGINEERING COLLEGE An Autonomous Institution, Affiliated to Anna University Chennai, & Approved by AICTE Delhi Department of Computer Science and Engineering UNIT 1 – ARRAY AND LINKED LIST Dr. USHA M Associate Professor Dept of CSE Velammal Engineering College
Introduction To Data Structures And List ADT Mrs. G. Sumathi Assistant Professor Velammal Engineering College Chennai VELAMMAL ENGINEERING COLLEGE An Autonomous Institution, Affiliated to Anna University Chennai, & Approved by AICTE Delhi
Dept of CSE, Velammal Engineering College, Chennai 3 Agenda • Introduction to Data Structures • List ADT • Issues in Array Implementation • Linked List Representation • Types • Applications of Linked List 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 5 Introduction to Data Structures Definition: Data Structure is a way of organizing, storing and retrieving data and their relationships with each other 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 6 Classification of Data Structures Data Structure Primitive int char float boolean Non - Primitive Linear Array Linked List Stack Queue Non - Linear Tree Graph 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 9 • List ADT can be represented in two ways – Array – Linked List List ADT 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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; }; 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 14 Statement to create a node: n= (struct node*) malloc(sizeof(sturct node)) nnext =NULL; Creating a Node struct node { int data; struct node *next; } *n; 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 15 • Singly linked list • Doubly linked list • Circular linked list Types of Linked List 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 16 • 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) 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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; 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 21 Routine for Deletion at the Beginning void del_beg () { t=head; head=tnext; free(t); } 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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); } 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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; 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 32 void del_beg_dll () { t=head; head=headnext; headprev=NULL; free(t); } Routine for Deletion at the Beginning t is freed 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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); } 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 34 Routine for Deletion at the Middle void del_mid_dll (int num) //Let num=9 { t=head; while(tdata!=num) { t=tnext; } tprevnext=tnext; tnextprev=tprev; free(t); } 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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!! 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 !! 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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!! 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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; } 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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; } 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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; } 25/5/2020
Dept of CSE, Velammal Engineering College, Chennai 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., 25/5/2020

More Related Content

PPTX
Tree Data Structures with Types, Properties, Traversals, Advanced Variants, a...
usham61
 
PPTX
Graph Data Structures with Types, Traversals, Connectivity, and Real-Life App...
usham61
 
PPTX
tack Data Structure with Array and Linked List Implementation, Push and Pop O...
usham61
 
PPTX
Sorting and Hashing in Data Structures with Algorithms, Techniques, Implement...
usham61
 
PPTX
Graph Data Structure Concepts with Types, Representations, Traversal Techniqu...
usham61
 
PPTX
Application of graph ,biconnectivity FDP on DS.pptx
usham61
 
PPTX
Real-Life Applications of Graph Data Structures in Networks, Social Media, Sh...
usham61
 
PPTX
AVL Tree Data Structure with Insertion, Deletion, Rotations, Balancing Techni...
usham61
 
Tree Data Structures with Types, Properties, Traversals, Advanced Variants, a...
usham61
 
Graph Data Structures with Types, Traversals, Connectivity, and Real-Life App...
usham61
 
tack Data Structure with Array and Linked List Implementation, Push and Pop O...
usham61
 
Sorting and Hashing in Data Structures with Algorithms, Techniques, Implement...
usham61
 
Graph Data Structure Concepts with Types, Representations, Traversal Techniqu...
usham61
 
Application of graph ,biconnectivity FDP on DS.pptx
usham61
 
Real-Life Applications of Graph Data Structures in Networks, Social Media, Sh...
usham61
 
AVL Tree Data Structure with Insertion, Deletion, Rotations, Balancing Techni...
usham61
 

More from usham61 (6)

PPTX
B Tree Data Structure Concepts with Insertion, Deletion, Searching, and Appli...
usham61
 
PPTX
Tree Traversal Techniques in Data Structures with Inorder, Preorder, Postorde...
usham61
 
PPT
AVL Tree Animation with Rotations, Balancing Techniques, and Step-by-Step Ope...
usham61
 
PPTX
Comprehensive Guide to Queue Data Structure with Operations, Types, and Appli...
usham61
 
PPTX
Introduction to Arrays and Linked Lists with Operations, Types, and Applicati...
usham61
 
PPTX
Stack Data Structure Explained with Array and Linked List Implementation, Ope...
usham61
 
B Tree Data Structure Concepts with Insertion, Deletion, Searching, and Appli...
usham61
 
Tree Traversal Techniques in Data Structures with Inorder, Preorder, Postorde...
usham61
 
AVL Tree Animation with Rotations, Balancing Techniques, and Step-by-Step Ope...
usham61
 
Comprehensive Guide to Queue Data Structure with Operations, Types, and Appli...
usham61
 
Introduction to Arrays and Linked Lists with Operations, Types, and Applicati...
usham61
 
Stack Data Structure Explained with Array and Linked List Implementation, Ope...
usham61
 
Ad

Recently uploaded (20)

PDF
Unit I ESSENTIAL OF DIGITAL MARKETING.pdf
Nitin Shelake
 
PDF
COURSE DESCRIPTOR OF SURVEYING R24 SYLLABUS
MNANDITHACIVILSTAFF
 
PDF
22EC502-MICROCONTROLLER AND INTERFACING-8051 MICROCONTROLLER.pdf
RajalakshmiSermadura
 
PPTX
introduction to high performance computing
JuanDavid747466
 
PDF
August 2025 - Top 10 Read Articles in Network Security & Its Applications
IJNSA Journal
 
PDF
R24 SURVEYING LAB MANUAL for civil enggi
MNANDITHACIVILSTAFF
 
PDF
Soil Improvement Techniques Note - Rabbi
rahmatideal000
 
PPTX
Information Storage and Retrieval Techniques Unit III
jeyamohan2519
 
PPT
INTRODUCTION -Data Warehousing and Mining-M.Tech- VTU.ppt
Subramanyam Natarajan
 
PPTX
Safety Seminar civil to be ensured for safe working.
DILJEETKUMAR8
 
PPTX
Nature of X-rays, X- Ray Equipment, Fluoroscopy
DJERALDINAUXILLIAECE
 
PPTX
CURRICULAM DESIGN engineering FOR CSE 2025.pptx
Amuda3
 
PPTX
Fundamentals of Mechanical Engineering.pptx
MdMowdudAhmed
 
PPTX
Module 8- Technological and Communication Skills.pptx
Ramya Nellutla
 
PPTX
6ME3A-Unit-II-Sensors and Actuators_Handouts.pptx
anukaranugi
 
PDF
Human-AI Collaboration: Balancing Agentic AI and Autonomy in Hybrid Systems
ijccsa
 
PDF
PREDICTION OF DIABETES FROM ELECTRONIC HEALTH RECORDS
ijaia
 
PDF
UNIT no 1 INTRODUCTION TO DBMS NOTES.pdf
pawarbhaktiit
 
PDF
SMART SIGNAL TIMING FOR URBAN INTERSECTIONS USING REAL-TIME VEHICLE DETECTI...
Niraj Aarya
 
PDF
A SYSTEMATIC REVIEW OF APPLICATIONS IN FRAUD DETECTION
IJNSA Journal
 
Unit I ESSENTIAL OF DIGITAL MARKETING.pdf
Nitin Shelake
 
COURSE DESCRIPTOR OF SURVEYING R24 SYLLABUS
MNANDITHACIVILSTAFF
 
22EC502-MICROCONTROLLER AND INTERFACING-8051 MICROCONTROLLER.pdf
RajalakshmiSermadura
 
introduction to high performance computing
JuanDavid747466
 
August 2025 - Top 10 Read Articles in Network Security & Its Applications
IJNSA Journal
 
R24 SURVEYING LAB MANUAL for civil enggi
MNANDITHACIVILSTAFF
 
Soil Improvement Techniques Note - Rabbi
rahmatideal000
 
Information Storage and Retrieval Techniques Unit III
jeyamohan2519
 
INTRODUCTION -Data Warehousing and Mining-M.Tech- VTU.ppt
Subramanyam Natarajan
 
Safety Seminar civil to be ensured for safe working.
DILJEETKUMAR8
 
Nature of X-rays, X- Ray Equipment, Fluoroscopy
DJERALDINAUXILLIAECE
 
CURRICULAM DESIGN engineering FOR CSE 2025.pptx
Amuda3
 
Fundamentals of Mechanical Engineering.pptx
MdMowdudAhmed
 
Module 8- Technological and Communication Skills.pptx
Ramya Nellutla
 
6ME3A-Unit-II-Sensors and Actuators_Handouts.pptx
anukaranugi
 
Human-AI Collaboration: Balancing Agentic AI and Autonomy in Hybrid Systems
ijccsa
 
PREDICTION OF DIABETES FROM ELECTRONIC HEALTH RECORDS
ijaia
 
UNIT no 1 INTRODUCTION TO DBMS NOTES.pdf
pawarbhaktiit
 
SMART SIGNAL TIMING FOR URBAN INTERSECTIONS USING REAL-TIME VEHICLE DETECTI...
Niraj Aarya
 
A SYSTEMATIC REVIEW OF APPLICATIONS IN FRAUD DETECTION
IJNSA Journal
 
Ad

"Array and Linked List in Data Structures with Types, Operations, Implementations, and Applications in C Programming"

  • 1. VELAMMAL ENGINEERING COLLEGE An Autonomous Institution, Affiliated to Anna University Chennai, & Approved by AICTE Delhi Department of Computer Science and Engineering UNIT 1 – ARRAY AND LINKED LIST Dr. USHA M Associate Professor Dept of CSE Velammal Engineering College
  • 2. Introduction To Data Structures And List ADT Mrs. G. Sumathi Assistant Professor Velammal Engineering College Chennai VELAMMAL ENGINEERING COLLEGE An Autonomous Institution, Affiliated to Anna University Chennai, & Approved by AICTE Delhi
  • 3. Dept of CSE, Velammal Engineering College, Chennai 3 Agenda • Introduction to Data Structures • List ADT • Issues in Array Implementation • Linked List Representation • Types • Applications of Linked List 25/5/2020
  • 4. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 5. Dept of CSE, Velammal Engineering College, Chennai 5 Introduction to Data Structures Definition: Data Structure is a way of organizing, storing and retrieving data and their relationships with each other 25/5/2020
  • 6. Dept of CSE, Velammal Engineering College, Chennai 6 Classification of Data Structures Data Structure Primitive int char float boolean Non - Primitive Linear Array Linked List Stack Queue Non - Linear Tree Graph 25/5/2020
  • 7. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 8. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 9. Dept of CSE, Velammal Engineering College, Chennai 9 • List ADT can be represented in two ways – Array – Linked List List ADT 25/5/2020
  • 10. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 11. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 12. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 13. Dept of CSE, Velammal Engineering College, Chennai 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; }; 25/5/2020
  • 14. Dept of CSE, Velammal Engineering College, Chennai 14 Statement to create a node: n= (struct node*) malloc(sizeof(sturct node)) nnext =NULL; Creating a Node struct node { int data; struct node *next; } *n; 25/5/2020
  • 15. Dept of CSE, Velammal Engineering College, Chennai 15 • Singly linked list • Doubly linked list • Circular linked list Types of Linked List 25/5/2020
  • 16. Dept of CSE, Velammal Engineering College, Chennai 16 • 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) 25/5/2020
  • 17. Dept of CSE, Velammal Engineering College, Chennai 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; 25/5/2020
  • 18. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 19. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 20. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 21. Dept of CSE, Velammal Engineering College, Chennai 21 Routine for Deletion at the Beginning void del_beg () { t=head; head=tnext; free(t); } 25/5/2020
  • 22. Dept of CSE, Velammal Engineering College, Chennai 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); } 25/5/2020
  • 23. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 24. Dept of CSE, Velammal Engineering College, Chennai 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/5/2020
  • 25. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 26. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 27. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 28. Dept of CSE, Velammal Engineering College, Chennai 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; 25/5/2020
  • 29. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 30. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 31. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 32. Dept of CSE, Velammal Engineering College, Chennai 32 void del_beg_dll () { t=head; head=headnext; headprev=NULL; free(t); } Routine for Deletion at the Beginning t is freed 25/5/2020
  • 33. Dept of CSE, Velammal Engineering College, Chennai 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); } 25/5/2020
  • 34. Dept of CSE, Velammal Engineering College, Chennai 34 Routine for Deletion at the Middle void del_mid_dll (int num) //Let num=9 { t=head; while(tdata!=num) { t=tnext; } tprevnext=tnext; tnextprev=tprev; free(t); } 25/5/2020
  • 35. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 36. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 37. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 38. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 39. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 40. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 41. Dept of CSE, Velammal Engineering College, Chennai 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!! 25/5/2020
  • 42. Dept of CSE, Velammal Engineering College, Chennai 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 !! 25/5/2020
  • 43. Dept of CSE, Velammal Engineering College, Chennai 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!! 25/5/2020
  • 44. Dept of CSE, Velammal Engineering College, Chennai 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; } 25/5/2020
  • 45. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 46. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 47. Dept of CSE, Velammal Engineering College, Chennai 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 25/5/2020
  • 48. Dept of CSE, Velammal Engineering College, Chennai 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; } 25/5/2020
  • 49. Dept of CSE, Velammal Engineering College, Chennai 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; } 25/5/2020
  • 50. Dept of CSE, Velammal Engineering College, Chennai 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., 25/5/2020

Editor's Notes

  • #24: If element not found, t=NULL, so NULL will be returned
  • #39: In CLL, ins at begin and ins at end are almost same with a difference that n will not be assigned as head in ins at end
  • #46: Multiprocessing of applications – all the applications will be stored in nodes of the list. OS has a fixed time for running each application