SlideShare a Scribd company logo

cs201-list-stack-queue-linked-list (2).ppt

Download as PPT, PDF
4
4kdishinfo

The document explains data structures and algorithms, focusing on linked lists, stacks, and queues. It defines key concepts such as abstract data types (ADTs), typical operations on data, and how to implement these data structures using arrays or linked lists. It also discusses specific operations related to each structure, including insertion, deletion, and traversal, as well as real-world applications of stacks and queues.

Engineering
1 of 64
Download to read offline
1
2
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
Data Structures and Algorithms Linked Lists, Stacks and Queues
11/17/24 CS 201 Data Structure • A construct that can be defined within a programming language to store a collection of data – one may store some data in an array of integers, an array of objects, or an array of arrays
11/17/24 CS 201 Abstract Data Type (ADT) • Definition: a collection of data together with a set of operations on that data – specifications indicate what ADT operations do, but not how to implement them – data structures are part of an ADT’s implementation • Programmer can use an ADT without knowing its implementation.
11/17/24 CS 201 Typical Operations on Data • Add data to a data collection • Remove data from a data collection • Ask questions about the data in a data collection. E.g., what is the value at a particular location, and is x in the collection?
11/17/24 CS 201 Why ADT • Hide the unnecessary details • Help manage software complexity • Easier software maintenance • Functionalities are less likely to change • Localised rather than global changes
11/17/24 CS 201 Illustration
Linked Lists
11/17/24 CS 201 Lists • List: a finite sequence of data items a1, a2, a3, …, an • Lists are pervasive in computing – e.g. class list, list of chars, list of events • Typical operations: – Creation – Insert / remove an element – Test for emptiness – Find an item/element – Current element / next / previous – Find k-th element – Print the entire list
11/17/24 CS 201 Array-Based List Implementation • One simple implementation is to use arrays – A sequence of n-elements • Maximum size is anticipated a priori. • Internal variables: – Maximum size maxSize (m) – Current size curSize (n) – Current index cur – Array of elements listArray n curSize a1 a2 a3 an listArray unused 0 1 2 n-1 m cur
11/17/24 CS 201 Inserting Into an Array • While retrieval is very fast, insertion and deletion are very slow – Insert has to shift upwards to create gap a1 a2 a7 a8 a4 a5 a6 a3 Step 1 : Shift upwards 8 Size arr 8 a1 a2 a3 a7 a8 Size arr a4 a5 a6 Example : insert(2, it, arr) Step 2 : Write into gap it Step 3 : Update Size 9
11/17/24 CS 201 Coding typedef struct { int arr[MAX]; int max; int size; } LIST void insert(int j, int it, LIST *pl) { // pre : 1<=j<=size+1 int i; for (i=pl->size; i>=j; i=i-1) // Step 1: Create gap { pl->arr[i+1]= pl->arr[i]; }; pl->arr[j]= it; // Step 2: Write to gap pl->size = pl->size + 1; // Step 3: Update size }
11/17/24 CS 201 Deleting from an Array • Delete has to shift downwards to close gap of deleted item Step 1 : Close Gap 9 a1 a2 it a7 a8 size a5 a6 a3 a8 arr 9 a1 a2 it a7 a8 size a4 a5 a6 a3 arr Example: deleteItem(4, arr) Step 2 : Update Size 8 Not part of list
11/17/24 CS 201 Coding void delete(int j, LIST *pl) { // pre : 1<=j<=size for (i=j+1; i<=pl->size; i=i+1) // Step1: Close gap { pl->arr[i-i]=pl->arr[i]; }; // Step 2: Update size pl->size = pl->size - 1; }
11/17/24 CS 201 Linked List Approach • Main problem of array is the slow deletion/insertion since it has to shift items in its contiguous memory • Solution: linked list where items need not be contiguous with nodes of the form • Sequence (list) of four items < a1,a2 ,a3 ,a4 > can be represented by: item next ai a1 a2 a3 a4 head represents null
Pointer-Based Linked Lists • A node in a linked list is usually a struct struct Node { int item Node *next; }; //end struct • A node is dynamically allocated Node *p; p = malloc(sizeof(Node)); A node 11/17/24 CS 201
Pointer-Based Linked Lists • The head pointer points to the first node in a linked list • If head is NULL, the linked list is empty – head=NULL • head=malloc(sizeof(Node)) 11/17/24 CS 201
A Sample Linked List 11/17/24 CS 201
Traverse a Linked List • Reference a node member with the -> operator p->item; • A traverse operation visits each node in the linked list – A pointer variable cur keeps track of the current node for (Node *cur = head; cur != NULL; cur = cur->next) x = cur->item; 11/17/24 CS 201
Traverse a Linked List The effect of the assignment cur = cur->next 11/17/24 CS 201
Delete a Node from a Linked List • Deleting an interior/last node prev->next=cur->next; • Deleting the first node head=head->next; • Return deleted node to system cur->next = NULL; free(cur); cur=NULL; 11/17/24 CS 201
Delete a Node from a Linked List Deleting a node from a linked list Deleting the first node 11/17/24 CS 201
Insert a Node into a Linked List • To insert a node between two nodes newPtr->next = cur; prev->next = newPtr; Inserting a new node into a linked list CS 201
Insert a Node into a Linked List • To insert a node at the beginning of a linked list newPtr->next = head; head = newPtr; Inserting at the beginning of a linked list CS 201
Insert a Node into a Linked List • Inserting at the end of a linked list is not a special case if cur is NULL newPtr->next = cur; prev->next = newPtr; Inserting at the end of a linked list CS 201
Look up BOOLEAN lookup (int x, Node *L) { if (L == NULL) return FALSE else if (x == L->item) return TRUE else return lookup(x, L-next); } 11/17/24 CS 201
An ADT Interface for List • Functions – isEmpty – getLength – insert – delete – Lookup – … • Data Members – head – Size • Local variables to member functions – cur – prev 11/17/24 CS 201
11/17/24 CS 201 Doubly Liked Lists • Frequently, we need to traverse a sequence in BOTH directions efficiently • Solution : Use doubly-linked list where each node has two pointers next forward traversal Doubly Linked List. x1 x4 x2 head x3 backward traversal prev
11/17/24 CS 201 Circular Linked Lists • May need to cycle through a list repeatedly, e.g. round robin system for a shared resource • Solution : Have the last node point to the first node x1 x2 xn . . . Circular Linked List. head
Stacks
11/17/24 CS 201 What is a Stack? • A stack is a list with the restriction that insertions and deletions can be performed in only one position, namely, the end of the list, called the top. • The operations: push (insert) and pop (delete) pop push(o) 6 7 2 3 Top
11/17/24 CS 201 Stack ADT Interface • The main functions in the Stack ADT are (S is the stack) boolean isEmpty(); // return true if empty boolean isFull(S); // return true if full void push(S, item); // insert item into stack void pop(S); // remove most recent item void clear(S); // remove all items from stack Item top(S); // retrieve most recent item Item topAndPop(S); // return & remove most recent item
11/17/24 CS 201 Sample Operation Stack S = malloc(sizeof(stack)); push(S, “a”); push(S, “b”); push(S, “c”); d=top(S); pop(S); push(S, “e”); pop(S); s a b c top e d
11/17/24 CS 201 Implementation by Linked Lists • Can use a Linked List as implementation of stack Top of Stack = Front of Linked-List StackLL lst a1 a2 a3 a4 head LinkedListItr
11/17/24 CS 201 Code struct Node { int element; Node * next; }; typedef struct Node * STACK;
11/17/24 CS 201 More code
More Code 11/17/24 CS 201
11/17/24 CS 201 Implementation by Array • use Array with a top index pointer as an implementation of stack E F 0 1 7 8 9 2 3 4 5 6 A B C D top StackAr arr A
11/17/24 CS 201 Code
11/17/24 CS 201 More code
11/17/24 CS 201 More code
Effects 11/17/24 CS 201
11/17/24 CS 201 Applications • Many application areas use stacks: – line editing – bracket matching – postfix calculation – function call stack
11/17/24 CS 201 Line Editing • A line editor would place characters read into a buffer but may use a backspace symbol (denoted by ) to do error correction • Refined Task – read in a line – correct the errors via backspace – print the corrected line in reverse Input : Corrected Input : Reversed Output : abc_defgh2klpqrwxyz abc_defg2klpwxyz zyxwplk2gfed_cba
11/17/24 CS 201 The Procedure • Initialize a new stack • For each character read: – if it is a backspace, pop out last char entered – if not a backspace, push the char into stack • To print in reverse, pop out each char for output Input : fghryz Corrected Input : Reversed Output : fyz zyf Stack f g h r y z
11/17/24 CS 201 Bracket Matching Problem • Ensures that pairs of brackets are properly matched • An Example: {a,(b+f[4])*3,d+f[5]} • Bad Examples: (..)..) // too many closing brackets (..(..) // too many open brackets [..(..]..) // mismatched brackets
11/17/24 CS 201 Informal Procedure Initialize the stack to empty For every char read if open bracket then push onto stack if close bracket, then return & remove most recent item from the stack if doesn’t match then flag error if non-bracket, skip the char read Example {a,(b+f[4])*3,d+f[5]} Stack { ( [ ) } ] [ ]
11/17/24 CS 201 Postfix Calculator • Computation of arithmetic expressions can be efficiently carried out in Postfix notation with the help of a stack. Infix - arg1 op arg2 Prefix - op arg1 arg2 Postfix - arg1 arg2 op (2*3)+4 2*(3+4) 2 3 4 + * 2*3+4 infix 2 3 * 4 + postfix
11/17/24 CS 201 Informal Procedure Initialise stack S For each item read. If it is an operand, push on the stack If it is an operator, pop arguments from stack; perform operation; push result onto the stack 2 3 4 Stack Expr 2 3 4 + * push(S, 2) push(S, 3) push(S, 4) arg2=topAndPop(S) arg1=topAndPop(S) push(S, arg1+arg2) arg2=topAndPop(S) arg1=topAndPop(S) push(S, arg1*arg2) 3+4=7 2*7=14
11/17/24 CS 201 Summary • The ADT stack operations have a last- in, first-out (LIFO) behavior • Stack has many applications – algorithms that operate on algebraic expressions – a strong relationship between recursion and stacks exists • Stack can be implemented using arrays or linked lists
Queues
11/17/24 CS 201 What is a Queue? • Like stacks, queues are lists. With a queue, however, insertion is done at one end whereas deletion is done at the other end. • Queues implement the FIFO (first-in first-out) policy. E.g., a printer/job queue! • Two basic operations of queues: – dequeue: remove an item/element from front – enqueue: add an item/element at the back dequeue enqueue
11/17/24 CS 201 Queue ADT • Queues implement the FIFO (first-in first-out) policy – An example is the printer/job queue! enqueue(o) dequeue() isEmpty() getFront() createQueue()
11/17/24 CS 201 Sample Operation Queue *Q; enqueue(Q, “a”); enqueue(Q, “b”); enqueue(Q, “c”); d=getFront(Q); dequeue(Q); enqueue(Q, “e”); dequeue(Q); q front back a b c e d
11/17/24 CS 201 Queue ADT interface • The main functions in the Queue ADT are (Q is the queue) void enqueue(o, Q) // insert o to back of Q void dequeue(Q); // remove oldest item Item getFront(Q); // retrieve oldest item boolean isEmpty(Q); // checks if Q is empty boolean isFull(Q); // checks if Q is full void clear(Q); // make Q empty }
11/17/24 CS 201 Implementation of Queue (Linked List) • Can use LinkedListItr as underlying implementation of Queues a1 a2 a3 a4 head tail Queue lst LinkedList addTail
11/17/24 CS 201 Code struct Node { int element; Node * next; }; struct QUEUE { Node * front; Node * rear; };
11/17/24 CS 201 More code
More code 11/17/24 CS 201 CELL is a list node
11/17/24 CS 201 Implementation of Queue (Array) • use Array with front and back pointers as implementation of queue Queue arr 0 1 7 8 9 2 3 4 5 6 A B C D E F G front back
11/17/24 CS 201 Circular Array • To implement queue, it is best to view arrays as circular structure 0 1 7 8 9 2 3 4 5 6 A B C D E F G front back front back A B C D E F G 0 1 7 8 9 2 3 4 5 6 Circular view of arrays.
11/17/24 CS 201 How to Advance • Both front & back pointers should make advancement until they reach end of the array. Then, they should re-point to beginning of the array front = adv(front); back = adv(back); int adv(int p) { return ((p+1) % maxsize); } Alternatively, use modular arithmetic: mod operator int adv(int p) { int r = p+1; if (r<maxsize) return r; else return 0; } upper bound of the array
11/17/24 CS 201 Sample Queue *Q; enqueue(Q, “a”); enqueue(Q, “b”); enqueue(Q, “c”); dequeue(Q); dequeue(Q); enqueue(Q, “d”); enqueue(Q, “e”); dequeue(Q); a Q F=front B=back F B b c d F B B B F F B B e
11/17/24 CS 201 Checking for Full/Empty State What does (F==B) denote? F B Queue Empty State c d e B F f Queue Full State size 0 size 4 c d e B F Alternative - Leave a Deliberate Gap! No need for size field. Full Case : (adv(B)==F)
11/17/24 CS 201 Summary • The definition of the queue operations gives the ADT queue first-in, first-out (FIFO) behavior • The queue can be implemented by linked lists or by arrays • There are many applications – Printer queues, – Telecommunication queues, – Simulations, – Etc.

More Related Content

Similar to cs201-list-stack-queue-linked-list (2).ppt (20)

PPTX
DSA_Unit3_ Stacks and Queues using array (1).pptx
nandinigujarathi9
 
PPSX
Stacks fundamentals
greatqadirgee4u
 
PPTX
introduction of the Stacks and Queues.pptx
kavitashingi123
 
PPTX
Stack ADT
MrsKArunasakthiCSE22
 
PPT
Unit i(dsc++)
Durga Devi
 
PPT
Data Structures and algorithms using c .ppt
RaviKumarChavali1
 
PPT
Data structures
Jauhar Amir
 
PPTX
STACKS AND QUEUES CONCEPTS
Malikireddy Bramhananda Reddy
 
PDF
Chapter 4 stack
jadhav_priti
 
PPTX
Introduction in Data Structure - stack, Queue
BharathiKrishna6
 
PPTX
Data Structures Algorithms and Applications
harshavardhan543715
 
PPTX
Stack and queue power point presentation data structure and algorithms Stack-...
abhaysingh19149
 
PPTX
Unit II - LINEAR DATA STRUCTURES
Usha Mahalingam
 
PPTX
Revisiting a data structures in detail with linked list stack and queue
ssuser7319f8
 
PPTX
stacks and queues
EktaVaswani2
 
PPTX
Stack in Sata Structure
Muhazzab Chouhadry
 
PPTX
c programming and data structure notes for ECE
ShaMaa11
 
PDF
Fjdkkdnncmckkgkhkhkkhkhkhkhkhkhkhkhkhkhhl
Borraramkumar
 
PDF
Chapter 5 Stack and Queue.pdf
GirT2
 
PPT
Lecture5
Muhammad Zubair
 
DSA_Unit3_ Stacks and Queues using array (1).pptx
nandinigujarathi9
 
Stacks fundamentals
greatqadirgee4u
 
introduction of the Stacks and Queues.pptx
kavitashingi123
 
Stack ADT
MrsKArunasakthiCSE22
 
Unit i(dsc++)
Durga Devi
 
Data Structures and algorithms using c .ppt
RaviKumarChavali1
 
Data structures
Jauhar Amir
 
STACKS AND QUEUES CONCEPTS
Malikireddy Bramhananda Reddy
 
Chapter 4 stack
jadhav_priti
 
Introduction in Data Structure - stack, Queue
BharathiKrishna6
 
Data Structures Algorithms and Applications
harshavardhan543715
 
Stack and queue power point presentation data structure and algorithms Stack-...
abhaysingh19149
 
Unit II - LINEAR DATA STRUCTURES
Usha Mahalingam
 
Revisiting a data structures in detail with linked list stack and queue
ssuser7319f8
 
stacks and queues
EktaVaswani2
 
Stack in Sata Structure
Muhazzab Chouhadry
 
c programming and data structure notes for ECE
ShaMaa11
 
Fjdkkdnncmckkgkhkhkkhkhkhkhkhkhkhkhkhkhhl
Borraramkumar
 
Chapter 5 Stack and Queue.pdf
GirT2
 
Lecture5
Muhammad Zubair
 

Recently uploaded (20)

PDF
methodology-driven-mbse-murphy-july-hsv-huntsville6680038572db67488e78ff00003...
henriqueltorres1
 
PPTX
Unit_I Functional Units, Instruction Sets.pptx
logaprakash9
 
PPT
Footbinding.pptmnmkjkjkknmnnjkkkkkkkkkkkkkk
mamadoundiaye42742
 
PDF
MODULE-5 notes [BCG402-CG&V] PART-B.pdf
Alvas Institute of Engineering and technology, Moodabidri
 
PDF
Module - 5 Machine Learning-22ISE62.pdf
Dr. Shivashankar
 
PPTX
template.pptxr4t5y67yrttttttttttttttttttttttttttttttttttt
SithamparanaathanPir
 
PPTX
Seminar Description: YOLO v1 (You Only Look Once).pptx
abhijithpramod20002
 
PPTX
Distribution reservoir and service storage pptx
dhanashree78
 
PDF
20ES1152 Programming for Problem Solving Lab Manual VRSEC.pdf
Ashutosh Satapathy
 
PDF
Artificial Neural Network-Types,Perceptron,Problems
Sharmila Chidaravalli
 
PDF
REINFORCEMENT LEARNING IN DECISION MAKING SEMINAR REPORT
anushaashraf20
 
PPTX
Fundamentals of Quantitative Design and Analysis.pptx
aliali240367
 
PPTX
Biosensors, BioDevices, Biomediccal.pptx
AsimovRiyaz
 
PDF
Clustering Algorithms - Kmeans,Min ALgorithm
Sharmila Chidaravalli
 
PPTX
How Industrial Project Management Differs From Construction.pptx
jamespit799
 
PDF
Water Industry Process Automation & Control Monthly July 2025
Water Industry Process Automation & Control
 
PDF
mbse_An_Introduction_to_Arcadia_20150115.pdf
henriqueltorres1
 
PPTX
Basics of Electrical Engineering and electronics .pptx
PrabhuNarayan6
 
PDF
Tesia Dobrydnia - An Avid Hiker And Backpacker
Tesia Dobrydnia
 
PDF
Submit Your Papers-International Journal on Cybernetics & Informatics ( IJCI)
IJCI JOURNAL
 
methodology-driven-mbse-murphy-july-hsv-huntsville6680038572db67488e78ff00003...
henriqueltorres1
 
Unit_I Functional Units, Instruction Sets.pptx
logaprakash9
 
Footbinding.pptmnmkjkjkknmnnjkkkkkkkkkkkkkk
mamadoundiaye42742
 
MODULE-5 notes [BCG402-CG&V] PART-B.pdf
Alvas Institute of Engineering and technology, Moodabidri
 
Module - 5 Machine Learning-22ISE62.pdf
Dr. Shivashankar
 
template.pptxr4t5y67yrttttttttttttttttttttttttttttttttttt
SithamparanaathanPir
 
Seminar Description: YOLO v1 (You Only Look Once).pptx
abhijithpramod20002
 
Distribution reservoir and service storage pptx
dhanashree78
 
20ES1152 Programming for Problem Solving Lab Manual VRSEC.pdf
Ashutosh Satapathy
 
Artificial Neural Network-Types,Perceptron,Problems
Sharmila Chidaravalli
 
REINFORCEMENT LEARNING IN DECISION MAKING SEMINAR REPORT
anushaashraf20
 
Fundamentals of Quantitative Design and Analysis.pptx
aliali240367
 
Biosensors, BioDevices, Biomediccal.pptx
AsimovRiyaz
 
Clustering Algorithms - Kmeans,Min ALgorithm
Sharmila Chidaravalli
 
How Industrial Project Management Differs From Construction.pptx
jamespit799
 
Water Industry Process Automation & Control Monthly July 2025
Water Industry Process Automation & Control
 
mbse_An_Introduction_to_Arcadia_20150115.pdf
henriqueltorres1
 
Basics of Electrical Engineering and electronics .pptx
PrabhuNarayan6
 
Tesia Dobrydnia - An Avid Hiker And Backpacker
Tesia Dobrydnia
 
Submit Your Papers-International Journal on Cybernetics & Informatics ( IJCI)
IJCI JOURNAL
 
Ad

cs201-list-stack-queue-linked-list (2).ppt

  • 1. Data Structures and Algorithms Linked Lists, Stacks and Queues
  • 2. 11/17/24 CS 201 Data Structure • A construct that can be defined within a programming language to store a collection of data – one may store some data in an array of integers, an array of objects, or an array of arrays
  • 3. 11/17/24 CS 201 Abstract Data Type (ADT) • Definition: a collection of data together with a set of operations on that data – specifications indicate what ADT operations do, but not how to implement them – data structures are part of an ADT’s implementation • Programmer can use an ADT without knowing its implementation.
  • 4. 11/17/24 CS 201 Typical Operations on Data • Add data to a data collection • Remove data from a data collection • Ask questions about the data in a data collection. E.g., what is the value at a particular location, and is x in the collection?
  • 5. 11/17/24 CS 201 Why ADT • Hide the unnecessary details • Help manage software complexity • Easier software maintenance • Functionalities are less likely to change • Localised rather than global changes
  • 8. 11/17/24 CS 201 Lists • List: a finite sequence of data items a1, a2, a3, …, an • Lists are pervasive in computing – e.g. class list, list of chars, list of events • Typical operations: – Creation – Insert / remove an element – Test for emptiness – Find an item/element – Current element / next / previous – Find k-th element – Print the entire list
  • 9. 11/17/24 CS 201 Array-Based List Implementation • One simple implementation is to use arrays – A sequence of n-elements • Maximum size is anticipated a priori. • Internal variables: – Maximum size maxSize (m) – Current size curSize (n) – Current index cur – Array of elements listArray n curSize a1 a2 a3 an listArray unused 0 1 2 n-1 m cur
  • 10. 11/17/24 CS 201 Inserting Into an Array • While retrieval is very fast, insertion and deletion are very slow – Insert has to shift upwards to create gap a1 a2 a7 a8 a4 a5 a6 a3 Step 1 : Shift upwards 8 Size arr 8 a1 a2 a3 a7 a8 Size arr a4 a5 a6 Example : insert(2, it, arr) Step 2 : Write into gap it Step 3 : Update Size 9
  • 11. 11/17/24 CS 201 Coding typedef struct { int arr[MAX]; int max; int size; } LIST void insert(int j, int it, LIST *pl) { // pre : 1<=j<=size+1 int i; for (i=pl->size; i>=j; i=i-1) // Step 1: Create gap { pl->arr[i+1]= pl->arr[i]; }; pl->arr[j]= it; // Step 2: Write to gap pl->size = pl->size + 1; // Step 3: Update size }
  • 12. 11/17/24 CS 201 Deleting from an Array • Delete has to shift downwards to close gap of deleted item Step 1 : Close Gap 9 a1 a2 it a7 a8 size a5 a6 a3 a8 arr 9 a1 a2 it a7 a8 size a4 a5 a6 a3 arr Example: deleteItem(4, arr) Step 2 : Update Size 8 Not part of list
  • 13. 11/17/24 CS 201 Coding void delete(int j, LIST *pl) { // pre : 1<=j<=size for (i=j+1; i<=pl->size; i=i+1) // Step1: Close gap { pl->arr[i-i]=pl->arr[i]; }; // Step 2: Update size pl->size = pl->size - 1; }
  • 14. 11/17/24 CS 201 Linked List Approach • Main problem of array is the slow deletion/insertion since it has to shift items in its contiguous memory • Solution: linked list where items need not be contiguous with nodes of the form • Sequence (list) of four items < a1,a2 ,a3 ,a4 > can be represented by: item next ai a1 a2 a3 a4 head represents null
  • 15. Pointer-Based Linked Lists • A node in a linked list is usually a struct struct Node { int item Node *next; }; //end struct • A node is dynamically allocated Node *p; p = malloc(sizeof(Node)); A node 11/17/24 CS 201
  • 16. Pointer-Based Linked Lists • The head pointer points to the first node in a linked list • If head is NULL, the linked list is empty – head=NULL • head=malloc(sizeof(Node)) 11/17/24 CS 201
  • 17. A Sample Linked List 11/17/24 CS 201
  • 18. Traverse a Linked List • Reference a node member with the -> operator p->item; • A traverse operation visits each node in the linked list – A pointer variable cur keeps track of the current node for (Node *cur = head; cur != NULL; cur = cur->next) x = cur->item; 11/17/24 CS 201
  • 19. Traverse a Linked List The effect of the assignment cur = cur->next 11/17/24 CS 201
  • 20. Delete a Node from a Linked List • Deleting an interior/last node prev->next=cur->next; • Deleting the first node head=head->next; • Return deleted node to system cur->next = NULL; free(cur); cur=NULL; 11/17/24 CS 201
  • 21. Delete a Node from a Linked List Deleting a node from a linked list Deleting the first node 11/17/24 CS 201
  • 22. Insert a Node into a Linked List • To insert a node between two nodes newPtr->next = cur; prev->next = newPtr; Inserting a new node into a linked list CS 201
  • 23. Insert a Node into a Linked List • To insert a node at the beginning of a linked list newPtr->next = head; head = newPtr; Inserting at the beginning of a linked list CS 201
  • 24. Insert a Node into a Linked List • Inserting at the end of a linked list is not a special case if cur is NULL newPtr->next = cur; prev->next = newPtr; Inserting at the end of a linked list CS 201
  • 25. Look up BOOLEAN lookup (int x, Node *L) { if (L == NULL) return FALSE else if (x == L->item) return TRUE else return lookup(x, L-next); } 11/17/24 CS 201
  • 26. An ADT Interface for List • Functions – isEmpty – getLength – insert – delete – Lookup – … • Data Members – head – Size • Local variables to member functions – cur – prev 11/17/24 CS 201
  • 27. 11/17/24 CS 201 Doubly Liked Lists • Frequently, we need to traverse a sequence in BOTH directions efficiently • Solution : Use doubly-linked list where each node has two pointers next forward traversal Doubly Linked List. x1 x4 x2 head x3 backward traversal prev
  • 28. 11/17/24 CS 201 Circular Linked Lists • May need to cycle through a list repeatedly, e.g. round robin system for a shared resource • Solution : Have the last node point to the first node x1 x2 xn . . . Circular Linked List. head
  • 30. 11/17/24 CS 201 What is a Stack? • A stack is a list with the restriction that insertions and deletions can be performed in only one position, namely, the end of the list, called the top. • The operations: push (insert) and pop (delete) pop push(o) 6 7 2 3 Top
  • 31. 11/17/24 CS 201 Stack ADT Interface • The main functions in the Stack ADT are (S is the stack) boolean isEmpty(); // return true if empty boolean isFull(S); // return true if full void push(S, item); // insert item into stack void pop(S); // remove most recent item void clear(S); // remove all items from stack Item top(S); // retrieve most recent item Item topAndPop(S); // return & remove most recent item
  • 32. 11/17/24 CS 201 Sample Operation Stack S = malloc(sizeof(stack)); push(S, “a”); push(S, “b”); push(S, “c”); d=top(S); pop(S); push(S, “e”); pop(S); s a b c top e d
  • 33. 11/17/24 CS 201 Implementation by Linked Lists • Can use a Linked List as implementation of stack Top of Stack = Front of Linked-List StackLL lst a1 a2 a3 a4 head LinkedListItr
  • 34. 11/17/24 CS 201 Code struct Node { int element; Node * next; }; typedef struct Node * STACK;
  • 37. 11/17/24 CS 201 Implementation by Array • use Array with a top index pointer as an implementation of stack E F 0 1 7 8 9 2 3 4 5 6 A B C D top StackAr arr A
  • 42. 11/17/24 CS 201 Applications • Many application areas use stacks: – line editing – bracket matching – postfix calculation – function call stack
  • 43. 11/17/24 CS 201 Line Editing • A line editor would place characters read into a buffer but may use a backspace symbol (denoted by ) to do error correction • Refined Task – read in a line – correct the errors via backspace – print the corrected line in reverse Input : Corrected Input : Reversed Output : abc_defgh2klpqrwxyz abc_defg2klpwxyz zyxwplk2gfed_cba
  • 44. 11/17/24 CS 201 The Procedure • Initialize a new stack • For each character read: – if it is a backspace, pop out last char entered – if not a backspace, push the char into stack • To print in reverse, pop out each char for output Input : fghryz Corrected Input : Reversed Output : fyz zyf Stack f g h r y z
  • 45. 11/17/24 CS 201 Bracket Matching Problem • Ensures that pairs of brackets are properly matched • An Example: {a,(b+f[4])*3,d+f[5]} • Bad Examples: (..)..) // too many closing brackets (..(..) // too many open brackets [..(..]..) // mismatched brackets
  • 46. 11/17/24 CS 201 Informal Procedure Initialize the stack to empty For every char read if open bracket then push onto stack if close bracket, then return & remove most recent item from the stack if doesn’t match then flag error if non-bracket, skip the char read Example {a,(b+f[4])*3,d+f[5]} Stack { ( [ ) } ] [ ]
  • 47. 11/17/24 CS 201 Postfix Calculator • Computation of arithmetic expressions can be efficiently carried out in Postfix notation with the help of a stack. Infix - arg1 op arg2 Prefix - op arg1 arg2 Postfix - arg1 arg2 op (2*3)+4 2*(3+4) 2 3 4 + * 2*3+4 infix 2 3 * 4 + postfix
  • 48. 11/17/24 CS 201 Informal Procedure Initialise stack S For each item read. If it is an operand, push on the stack If it is an operator, pop arguments from stack; perform operation; push result onto the stack 2 3 4 Stack Expr 2 3 4 + * push(S, 2) push(S, 3) push(S, 4) arg2=topAndPop(S) arg1=topAndPop(S) push(S, arg1+arg2) arg2=topAndPop(S) arg1=topAndPop(S) push(S, arg1*arg2) 3+4=7 2*7=14
  • 49. 11/17/24 CS 201 Summary • The ADT stack operations have a last- in, first-out (LIFO) behavior • Stack has many applications – algorithms that operate on algebraic expressions – a strong relationship between recursion and stacks exists • Stack can be implemented using arrays or linked lists
  • 51. 11/17/24 CS 201 What is a Queue? • Like stacks, queues are lists. With a queue, however, insertion is done at one end whereas deletion is done at the other end. • Queues implement the FIFO (first-in first-out) policy. E.g., a printer/job queue! • Two basic operations of queues: – dequeue: remove an item/element from front – enqueue: add an item/element at the back dequeue enqueue
  • 52. 11/17/24 CS 201 Queue ADT • Queues implement the FIFO (first-in first-out) policy – An example is the printer/job queue! enqueue(o) dequeue() isEmpty() getFront() createQueue()
  • 53. 11/17/24 CS 201 Sample Operation Queue *Q; enqueue(Q, “a”); enqueue(Q, “b”); enqueue(Q, “c”); d=getFront(Q); dequeue(Q); enqueue(Q, “e”); dequeue(Q); q front back a b c e d
  • 54. 11/17/24 CS 201 Queue ADT interface • The main functions in the Queue ADT are (Q is the queue) void enqueue(o, Q) // insert o to back of Q void dequeue(Q); // remove oldest item Item getFront(Q); // retrieve oldest item boolean isEmpty(Q); // checks if Q is empty boolean isFull(Q); // checks if Q is full void clear(Q); // make Q empty }
  • 55. 11/17/24 CS 201 Implementation of Queue (Linked List) • Can use LinkedListItr as underlying implementation of Queues a1 a2 a3 a4 head tail Queue lst LinkedList addTail
  • 56. 11/17/24 CS 201 Code struct Node { int element; Node * next; }; struct QUEUE { Node * front; Node * rear; };
  • 58. More code 11/17/24 CS 201 CELL is a list node
  • 59. 11/17/24 CS 201 Implementation of Queue (Array) • use Array with front and back pointers as implementation of queue Queue arr 0 1 7 8 9 2 3 4 5 6 A B C D E F G front back
  • 60. 11/17/24 CS 201 Circular Array • To implement queue, it is best to view arrays as circular structure 0 1 7 8 9 2 3 4 5 6 A B C D E F G front back front back A B C D E F G 0 1 7 8 9 2 3 4 5 6 Circular view of arrays.
  • 61. 11/17/24 CS 201 How to Advance • Both front & back pointers should make advancement until they reach end of the array. Then, they should re-point to beginning of the array front = adv(front); back = adv(back); int adv(int p) { return ((p+1) % maxsize); } Alternatively, use modular arithmetic: mod operator int adv(int p) { int r = p+1; if (r<maxsize) return r; else return 0; } upper bound of the array
  • 62. 11/17/24 CS 201 Sample Queue *Q; enqueue(Q, “a”); enqueue(Q, “b”); enqueue(Q, “c”); dequeue(Q); dequeue(Q); enqueue(Q, “d”); enqueue(Q, “e”); dequeue(Q); a Q F=front B=back F B b c d F B B B F F B B e
  • 63. 11/17/24 CS 201 Checking for Full/Empty State What does (F==B) denote? F B Queue Empty State c d e B F f Queue Full State size 0 size 4 c d e B F Alternative - Leave a Deliberate Gap! No need for size field. Full Case : (adv(B)==F)
  • 64. 11/17/24 CS 201 Summary • The definition of the queue operations gives the ADT queue first-in, first-out (FIFO) behavior • The queue can be implemented by linked lists or by arrays • There are many applications – Printer queues, – Telecommunication queues, – Simulations, – Etc.