SlideShare a Scribd company logo

07 ds and algorithm session_10

Niit Care, profile picture
Niit Care

The document discusses stacks and their implementation. It defines a stack as a LIFO data structure where elements can only be inserted or removed from the top. The basic stack operations are PUSH, which inserts an element onto the top of the stack, and POP, which removes the top element. Stacks can be used to check if parentheses in an arithmetic expression are correctly nested by scanning the expression and using a stack to match opening and closing parentheses.

TechnologyEducation
1 of 64
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 Objectives In this session, you will learn to: Identify the features of a stack Implement stacks Apply stacks to solve programming problems Ver. 1.0 Session 10
Data Structures and Algorithms Stacks • Let us play the game of Rummy. 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 6 6 6 6 6 6 6 6 Ver. 1.0 Session 10
Data Structures and Algorithms Defining a Stack A stack is Stack ? What is a a collection of data items that can be accessed at only one end, called top. Items can be inserted and deleted in a stack only at the top. The last item inserted in a stack is the first one to be deleted. Therefore, a stack is called a Last-In-First-Out (LIFO) data structure. Ver. 1.0 Session 10
Data Structures and Algorithms Identifying the Operations on Stacks • PUSH: It two process of inserting are performed There areis thebasic operations that a new element on the top of a stacks: stack. PUSH POP Push an Element 1 Empty Stack 1 Ver. 1.0 Session 10
Data Structures and Algorithms Identifying the Operations on Stacks (Contd.) • PUSH: It is the process of inserting a new element on the top of a stack. Push an Push an Element 2 Element 3 3 2 1 Ver. 1.0 Session 10
Data Structures and Algorithms Identifying the Operations on Stacks (Contd.) • POP: It is the process of deleting an element from the top of a stack. POP an Element 3 3 2 2 1 Ver. 1.0 Session 10
Data Structures and Algorithms Just a minute Elements in stacks are inserted and deleted on a ___________ basis. Answer: LIFO Ver. 1.0 Session 10
Data Structures and Algorithms Just a minute List down some real life examples that work on the LIFO principle. Answer: Pile of books: Suppose a set of books are placed one over the other in a pile. When you remove books from the pile, the topmost book will be removed first. Similarly, when you have to add a book to the pile, the book will be placed at the top of the pile. Pile of plates: The first plate begins the pile. The second plate is placed on the top of the first plate and the third plate is placed on the top of the second plate, and so on. In general, if you want to add a plate to the pile, you can keep it on the top of the pile. Similarly, if you want to remove a plate, you can remove the plate from the top of the pile. Bangles in a hand: When a person wears bangles, the last bangle worn is the first one to be removed. Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Stacks You need to develop a method to check if the parentheses in an arithmetic expression are correctly nested. How will you solve this problem? You can solve this problem easily by using a stack. Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} Consider an example. Suppose the expression is: {(a + b) × (c + d) + (c × d)]} Scan the expression from left to right. The first entry to be scanned is ‘{’, which is a left parenthesis. Push it into the stack. { Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} The next entry to be scanned is ‘(’, which is a left parenthesis. Push it into the stack. The next entry is ‘a’, which is an operand. Therefore, it is discarded. The next entry is ‘+’, which is an operator. Therefore, it is discarded. ( { The next entry is ‘b’, which is an operand. Therefore, it is discarded. Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} The next entry to be scanned is ‘)’, which is a right parenthesis POP the topmost entry from the stack. Match the two brackets. ( ) Brackets Matched ( { Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Stacks (Contd.) The next entry to be scanned {(a + b) × (c + d) + (c × d)]} is ‘×’, which is an operator. Therefore, it is discarded. The next entry to be scanned is ‘(’, which is a left parenthesis Push it into the stack The next entry to be scanned is ‘c’, which is an operand. Therefore it is discarded ( The next entry to be scanned { is ‘+’, which is an operator. Therefore it is discarded The next entry to be scanned is ‘d’, which is an operand. Therefore it is discarded Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} The next entry to be scanned is ‘)’, which is a right parenthesis. POP the topmost element from the stack. Match the two brackets. ( ) Brackets Matched ( { Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Stacks (Contd.) The next entry to be scanned {(a + b) × (c + d) + (c × d)]} is ‘+’, which is an operator. Therefore, it is discarded. The next entry to be scanned is ‘(’, which is a left parenthesis. Push it into the stack. The next entry to be scanned is ‘c’, which is an operand. Therefore, it is discarded. ( The next entry to be scanned { is ‘×’, which is an operator. Therefore, it is discarded. The next entry to be scanned is ‘d’, which is an operand. Therefore, it is discarded. Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} The next entry to be scanned is ‘)’, which is a right parenthesis. POP the topmost element from the stack. Match the two brackets. ( ) Brackets Matched ( { Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} The next entry to be scanned is ‘]’, which is a right parenthesis. POP the topmost element from the stack. Match the two brackets. { ] Brackets Do Not Match The Expression is INVALID { Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array A stack is similarstack list in which insertion and deletion is To implement a to a using an array: allowed only atarray: end. – Declare an one Therefore,Stack[5];a // Maximum size needs to be specified in int similar to list, stack can be implemented using both arrays and linked lists. // advance – Declare a variable, top to hold the index of the topmost element in the stacks: int top; – Initially, when the stack is empty, set: top = –1 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) Let us now write an algorithm for 1. Increment top by 1. the PUSH operation. 3. Store the value to be pushed at index top in Initially: the array. Top now top = – 1 contains the index of the topmost element. PUSH an element 3 0 1 2 3 4 Stack Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now top = – 1 contains the index of the topmost element. PUSH an element 3 0 1 2 3 4 Stack 10 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now top = 0 contains the index of the topmost element. PUSH an element 3 0 1 2 3 4 Stack 10 top = 0 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 3 0 1 2 3 4 Stack 3 10 Item pushed top = 0 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) 1. Increment top by 1. 3. Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 8 0 1 2 3 4 Stack 3 10 top = 0 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 8 0 1 2 3 4 Stack 3 10 top = 0 = 1 top Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 8 0 1 2 3 4 Stack 3 10 8 Item pushed top = 1 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) 1. Increment top by 1. 3. Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 5 0 1 2 3 4 Stack 3 10 8 top = 1 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 5 0 1 2 3 4 Stack 3 10 8 top = top = 2 1 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 5 0 1 2 3 4 Stack 3 10 8 5 Item pushed top = 2 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) 1. Increment top by 1. 3. Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 1 0 1 2 3 4 Stack 3 10 8 5 top = 2 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 1 0 1 2 3 4 Stack 3 10 8 5 top = 2 = 3 top Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 1 0 1 2 3 4 Stack 3 10 8 5 1 Item pushed top = 3 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) 1. Increment top by 1. 3. Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 9 0 1 2 3 4 Stack 3 10 8 5 1 top = 3 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 9 0 1 2 3 4 Stack 3 10 8 5 1 top = 3 = 4 top Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 9 0 1 2 3 4 Stack 3 10 8 5 1 9 Item pushed top = 4 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) 1. Increment top by 1. 3. Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 2 0 1 2 3 4 Stack 3 10 8 5 1 9 top = 4 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 2 0 1 2 3 4 Stack 3 10 8 5 1 9 top = 4top = 5 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 2 0 1 2 3 4 Stack 3 10 8 5 1 9 Stack overflow top = 5 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) The stack has been implemented To avoid the stack overflow, you 1. Increment top–by 1. If top = MAX 1: a. Display “Stack need to checksizethe stack full in an array of for 5. 3. Store the value to be Full” condition before pushing an element Therefore, you cannot store more pushed at index top in b. Exit the array. Top now into theelements in the stack. than 5 stack. 3. contains the index1of the Increment top by Let us modify the algorithm to check topmost element. 5. Store the value to be for this condition. pushed at index top in the array 0 1 2 3 4 Stack 3 10 8 5 1 9 Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) Write an algorithm to implement the POP operation on a stack. Algorithm for POP operation: 1. If top = – 1: a. Display “Stack Empty” b. Exit 4. Retrieve the value stored at index top 5. Decrement top by 1 Ver. 1.0 Session 10
Data Structures and Algorithms Just a minute In a stack, data can be stored and removed only from one end of the stack called the ______ of the stack. Answer: top Ver. 1.0 Session 10
Data Structures and Algorithms Implementing a Stack Using a Linked List Write an algorithm to implement theas follows: The algorithm for PUSH operation isPUSH and POP POP operation is as follows: operations using a Linkedtmp point to the topmost node. Make a memory for the List. 1. Allocatevariable/pointer new node. 2. Assign valuevalue contained in the topmost node. Retrieve the to the data field of the new node. 3. Make the next field of nextnew node point to top. top point to the the node in sequence. 4. Make topmemory allocatednode. node marked by tmp. Release point to the new to the Ver. 1.0 Session 10
Data Structures and Algorithms Activity: Implementing a Stack Using an Array Problem Statement: Write a program to implement a stack by using an array that can store five elements. Ver. 1.0 Session 10
Data Structures and Algorithms Activity: Implementing a Stack Using a Linked List Problem Statement: Write a program to implement a stack by using a linked list. Ver. 1.0 Session 10
Data Structures and Algorithms Just a minute What will be the condition for stack full in a stack implemented as a linked list? Answer: When a stack is implemented as a linked list, there is no upper bound limit on the size of the stack. Therefore, there will be no stack full condition in this case. Ver. 1.0 Session 10
Data Structures and Algorithms Just a minute If a stack is represented in memory by using a linked list, then insertion and deletion of data will be done ________. 1. At the end of the list 2. At the beginning of the list 3. Anywhere in the list 4. At the beginning and at the end of the list respectively Answer: 2. At the beginning of the list Ver. 1.0 Session 10
Data Structures and Algorithms Applications of Stacks Some of the applications of stacks are: Implementing function calls Maintaining the UNDO list for an application Checking the nesting of parentheses in an expression Evaluating expressions Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls Implementing function calls: Consider an example. There are three functions, F1, F2, and F3. Function F1 invokes F2 and function F2 invokes F3, as shown. Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() Assuming these instructions at the { given locations in the memory. 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() { The execution starts from 1100 int x; function F1 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x=5 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x=5 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } Address and the local variable of F1 void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x = 10 5 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x = 10 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 1122, x = 10 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } Address and the local variable of F2 void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x = 20 10 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 1122, x = 10 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } Address and the local variable of F2 void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x = 20 10 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) 1122, x = 10 { 1120 1122, x = 10 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; 20 } Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x=5 10 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) 1103, x = 5 { 1120 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; 20 10 } Ver. 1.0 Session 10
Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x=5 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; 20 10 5 } Ver. 1.0 Session 10
Data Structures and Algorithms Maintaining the UNDO list for an Application Maintaining the UNDO list for an application: Consider that you made some changes in a Word document. Now, you want to revert back those changes. You can revert those changes with the help of an UNDO feature. The UNDO feature reverts the changes in a LIFO manner. This means that the change that was made last is the first one to be reverted. You can implement the UNDO list by using a stack. Ver. 1.0 Session 10
Data Structures and Algorithms Checking the Nesting of Parentheses in an Expression Checking the nesting of parentheses in an expression: You can do this by checking the following two conditions: – The number of left parenthesis should be equal to the number of right parenthesis. – Each right parenthesis is preceded by a matching left parenthesis. Ver. 1.0 Session 10
Data Structures and Algorithms Evaluating Expressions Evaluating an expression by using stacks: Stacks can be used to solve complex arithmetic expressions. The evaluation of an expression is done in two steps: Conversion of the infix expression into a postfix expression. Evaluation of the postfix expression. Ver. 1.0 Session 10
Data Structures and Algorithms Activity: Implementing a Stack using a Linked List Problem Statement: Write a program that accepts an infix expression, and then converts it into a postfix expression. You can assume that the entered expression is a valid infix expression. Ver. 1.0 Session 10
Data Structures and Algorithms Summary In this session, you learned that: A stack is a collection of data items that can be accessed at only one end, called top. The last item inserted in a stack is the first one to be deleted. A stack is called a LIFO data structure. There are two operations that can be performed on stacks. They are: – PUSH – POP – Stacks can be implemented by using both arrays and linked lists. Ver. 1.0 Session 10
Data Structures and Algorithms Summary (Contd.) Stacks are used in many applications. Some of the application domains of stacks are as follows: Implementing function calls Maintaining the UNDO list for an application Checking the nesting of parentheses in an expression Evaluating expressions Ver. 1.0 Session 10

More Related Content

PPS
08 ds and algorithm session_11
Niit Care
 
PPS
ds and algorithm session
Varun Garg
 
PPS
03 ds and algorithm session_04
Niit Care
 
PPS
04 ds and algorithm session_05
Niit Care
 
PDF
computer notes - Priority queue
ecomputernotes
 
PPTX
Lecture08 stacks and-queues_v3
Hariz Mustafa
 
PPTX
Advanced data structures slide 2 2+
jomerson remorosa
 
PDF
Data structures "1" (Lectures 2015-2016)
Ameer B. Alaasam
 
08 ds and algorithm session_11
Niit Care
 
ds and algorithm session
Varun Garg
 
03 ds and algorithm session_04
Niit Care
 
04 ds and algorithm session_05
Niit Care
 
computer notes - Priority queue
ecomputernotes
 
Lecture08 stacks and-queues_v3
Hariz Mustafa
 
Advanced data structures slide 2 2+
jomerson remorosa
 
Data structures "1" (Lectures 2015-2016)
Ameer B. Alaasam
 

What's hot (20)

PDF
Week09
hccit
 
PDF
Dotnet programming concepts difference faqs- 2
Umar Ali
 
PDF
Preparation Data Structures 05 chain linear_list
Andres Mendez-Vazquez
 
PPTX
Lecture11 standard template-library
Hariz Mustafa
 
PPT
Tree
SHEETAL WAGHMARE
 
PPT
Chapter 4 ds
Hanif Durad
 
PPT
Notes DATA STRUCTURE - queue
Farhanum Aziera
 
PPTX
stacks and queues for public
iqbalphy1
 
PPTX
SQL Server Select Topics
Jay Coskey
 
PDF
Preparation Data Structures 01 introduction
Andres Mendez-Vazquez
 
PPTX
Binary tree
Afaq Mansoor Khan
 
PDF
C interview-questions-techpreparation
Kushaal Singla
 
PDF
Java - Arrays Concepts
Victer Paul
 
PPT
Chapter 7 ds
Hanif Durad
 
PDF
Preparation Data Structures 04 array linear_list
Andres Mendez-Vazquez
 
PDF
Optimizing array-based data structures to the limit
Roman Leventov
 
PPT
Tree & bst
Shakil Ahmed
 
PPTX
Class Diagram Uml
Trector Rancor
 
PPTX
Programming in C sesion 2
Prerna Sharma
 
DOCX
Top 50 oracle interview questions and answers
NIKUL GOYAL
 
Week09
hccit
 
Dotnet programming concepts difference faqs- 2
Umar Ali
 
Preparation Data Structures 05 chain linear_list
Andres Mendez-Vazquez
 
Lecture11 standard template-library
Hariz Mustafa
 
Tree
SHEETAL WAGHMARE
 
Chapter 4 ds
Hanif Durad
 
Notes DATA STRUCTURE - queue
Farhanum Aziera
 
stacks and queues for public
iqbalphy1
 
SQL Server Select Topics
Jay Coskey
 
Preparation Data Structures 01 introduction
Andres Mendez-Vazquez
 
Binary tree
Afaq Mansoor Khan
 
C interview-questions-techpreparation
Kushaal Singla
 
Java - Arrays Concepts
Victer Paul
 
Chapter 7 ds
Hanif Durad
 
Preparation Data Structures 04 array linear_list
Andres Mendez-Vazquez
 
Optimizing array-based data structures to the limit
Roman Leventov
 
Tree & bst
Shakil Ahmed
 
Class Diagram Uml
Trector Rancor
 
Programming in C sesion 2
Prerna Sharma
 
Top 50 oracle interview questions and answers
NIKUL GOYAL
 
Ad

Viewers also liked (19)

PPT
Operations on linked list
Sumathi Kv
 
PPT
Lec6 mod linked list
Ibrahim El-Torbany
 
PPT
Chapter 15
Bangabandhu Sheikh Mujibur Rahman Science and Technology University
 
PPT
Chap 13(dynamic memory allocation)
Bangabandhu Sheikh Mujibur Rahman Science and Technology University
 
PPS
05 ds and algorithm session_07
Niit Care
 
PPTX
Linked Lists
Hafiz Umair
 
PPTX
Applications of data structures
Wipro
 
PPT
Sparse Matrix and Polynomial
Aroosa Rajput
 
PDF
Multiplication of two 3 d sparse matrices using 1d arrays and linked lists
Dr Sandeep Kumar Poonia
 
PPTX
Sparse matrices
Zain Zafar
 
PPSX
Data Structure (Dynamic Array and Linked List)
Adam Mukharil Bachtiar
 
PPT
linked list
Narendra Chauhan
 
PPT
Linked list
Trupti Agrawal
 
PPTX
Linked list
akshat360
 
PPTX
Data structure and its types
Navtar Sidhu Brar
 
PDF
Top10 Innovative Ideas You Haven't Heard of in the Developing World
Mahindra Rise
 
PPTX
Data Structure
Karthikeyan A K
 
PPT
Lecture 1 data structures and algorithms
Aakash deep Singhal
 
PPT
DATA STRUCTURES
bca2010
 
Operations on linked list
Sumathi Kv
 
Lec6 mod linked list
Ibrahim El-Torbany
 
Chapter 15
Bangabandhu Sheikh Mujibur Rahman Science and Technology University
 
Chap 13(dynamic memory allocation)
Bangabandhu Sheikh Mujibur Rahman Science and Technology University
 
05 ds and algorithm session_07
Niit Care
 
Linked Lists
Hafiz Umair
 
Applications of data structures
Wipro
 
Sparse Matrix and Polynomial
Aroosa Rajput
 
Multiplication of two 3 d sparse matrices using 1d arrays and linked lists
Dr Sandeep Kumar Poonia
 
Sparse matrices
Zain Zafar
 
Data Structure (Dynamic Array and Linked List)
Adam Mukharil Bachtiar
 
linked list
Narendra Chauhan
 
Linked list
Trupti Agrawal
 
Linked list
akshat360
 
Data structure and its types
Navtar Sidhu Brar
 
Top10 Innovative Ideas You Haven't Heard of in the Developing World
Mahindra Rise
 
Data Structure
Karthikeyan A K
 
Lecture 1 data structures and algorithms
Aakash deep Singhal
 
DATA STRUCTURES
bca2010
 
Ad

Similar to 07 ds and algorithm session_10 (20)

PPT
stack data structure and its applications , advantages, disadvantages etc
rajinooka
 
PPT
stack data structure , applications, advantages
rajinooka
 
PPT
Linear Datsructure_stacks_Data Structure_PPT.ppt
rajinooka
 
PPT
stack is an ordered list in which insertion and deletion are done at one end,...
DrAmitAherwar1
 
PPTX
Stack data structure
Tech_MX
 
PPT
Stacks
Ashish Sethi
 
PPT
Data structure lecture7
Kumar
 
PPTX
Stacks Data structure.pptx
line24arts
 
PPT
Stack a Data Structure
ForwardBlog Enewzletter
 
PPTX
Data structures
Sneha Chopra
 
PPSX
Stacks fundamentals
greatqadirgee4u
 
PDF
Stack
Swarup Kumar Boro
 
PPT
Stacks
sweta dargad
 
PPTX
STACK.pptx
Dr.Shweta
 
PDF
Lecturestacks 110802115132-phpapp02
Jay Patel
 
PDF
stack
eShikshak
 
PPTX
stack.pptx
mayankKatiyar17
 
PPTX
Stacks IN DATA STRUCTURES
Sowmya Jyothi
 
PDF
computer notes - Evaluating postfix expressions
ecomputernotes
 
PPTX
U3.stack queue
Ssankett Negi
 
stack data structure and its applications , advantages, disadvantages etc
rajinooka
 
stack data structure , applications, advantages
rajinooka
 
Linear Datsructure_stacks_Data Structure_PPT.ppt
rajinooka
 
stack is an ordered list in which insertion and deletion are done at one end,...
DrAmitAherwar1
 
Stack data structure
Tech_MX
 
Stacks
Ashish Sethi
 
Data structure lecture7
Kumar
 
Stacks Data structure.pptx
line24arts
 
Stack a Data Structure
ForwardBlog Enewzletter
 
Data structures
Sneha Chopra
 
Stacks fundamentals
greatqadirgee4u
 
Stack
Swarup Kumar Boro
 
Stacks
sweta dargad
 
STACK.pptx
Dr.Shweta
 
Lecturestacks 110802115132-phpapp02
Jay Patel
 
stack
eShikshak
 
stack.pptx
mayankKatiyar17
 
Stacks IN DATA STRUCTURES
Sowmya Jyothi
 
computer notes - Evaluating postfix expressions
ecomputernotes
 
U3.stack queue
Ssankett Negi
 

More from Niit Care (20)

PPS
Ajs 1 b
Niit Care
 
PPS
Ajs 4 b
Niit Care
 
PPS
Ajs 4 a
Niit Care
 
PPS
Ajs 4 c
Niit Care
 
PPS
Ajs 3 b
Niit Care
 
PPS
Ajs 3 a
Niit Care
 
PPS
Ajs 3 c
Niit Care
 
PPS
Ajs 2 b
Niit Care
 
PPS
Ajs 2 a
Niit Care
 
PPS
Ajs 2 c
Niit Care
 
PPS
Ajs 1 a
Niit Care
 
PPS
Ajs 1 c
Niit Care
 
PPS
Dacj 4 2-c
Niit Care
 
PPS
Dacj 4 2-b
Niit Care
 
PPS
Dacj 4 2-a
Niit Care
 
PPS
Dacj 4 1-c
Niit Care
 
PPS
Dacj 4 1-b
Niit Care
 
PPS
Dacj 4 1-a
Niit Care
 
PPS
Dacj 1-2 b
Niit Care
 
PPS
Dacj 1-3 c
Niit Care
 
Ajs 1 b
Niit Care
 
Ajs 4 b
Niit Care
 
Ajs 4 a
Niit Care
 
Ajs 4 c
Niit Care
 
Ajs 3 b
Niit Care
 
Ajs 3 a
Niit Care
 
Ajs 3 c
Niit Care
 
Ajs 2 b
Niit Care
 
Ajs 2 a
Niit Care
 
Ajs 2 c
Niit Care
 
Ajs 1 a
Niit Care
 
Ajs 1 c
Niit Care
 
Dacj 4 2-c
Niit Care
 
Dacj 4 2-b
Niit Care
 
Dacj 4 2-a
Niit Care
 
Dacj 4 1-c
Niit Care
 
Dacj 4 1-b
Niit Care
 
Dacj 4 1-a
Niit Care
 
Dacj 1-2 b
Niit Care
 
Dacj 1-3 c
Niit Care
 

Recently uploaded (20)

PPTX
Machine Learning_overview_presentation.pptx
kondavamsidharreddy2
 
PDF
Approach and Philosophy of On baking technology
30anthuong17
 
PDF
Electronic commerce courselecture one. Pdf
OmerMohamed64
 
PPTX
VMware vSphere Foundation How to Sell Presentation-Ver1.4-2-14-2024.pptx
blackmambaettijean
 
PDF
Chapter 3 Spatial Domain Image Processing.pdf
Getnet Tigabie Askale -(GM)
 
PDF
Dropbox Q2 2025 Financial Results & Investor Presentation
Dropbox
 
PPTX
Programs and apps: productivity, graphics, security and other tools
4mqw9zch22
 
PDF
Machine learning based COVID-19 study performance prediction
IAESIJAI
 
PPTX
KOM of Painting work and Equipment Insulation REV00 update 25-dec.pptx
muhammadmuneebnaeem7
 
PDF
Network Security Unit 5.pdf for BCA BBA.
Serpent6
 
PDF
Spectral efficient network and resource selection model in 5G networks
IAESIJAI
 
PPT
Teaching material agriculture food technology
LiaRayya
 
PPTX
ACSFv1EN-58255 AWS Academy Cloud Security Foundations.pptx
23bcla24
 
PDF
Agricultural_Statistics_at_a_Glance_2022_0.pdf
SandeepSingh286037
 
PDF
cuic standard and advanced reporting.pdf
SimoneTitaniumTomase
 
PDF
Architecting across the Boundaries of two Complex Domains - Healthcare & Tech...
Peter Tan
 
PDF
Profit Center Accounting in SAP S/4HANA, S4F28 Col11
Libreria ERP
 
PDF
Peak of Data & AI Encore- AI for Metadata and Smarter Workflows
Safe Software
 
PDF
A comparative analysis of optical character recognition models for extracting...
IAESIJAI
 
PPTX
sap open course for s4hana steps from ECC to s4
sreeni2106invites
 
Machine Learning_overview_presentation.pptx
kondavamsidharreddy2
 
Approach and Philosophy of On baking technology
30anthuong17
 
Electronic commerce courselecture one. Pdf
OmerMohamed64
 
VMware vSphere Foundation How to Sell Presentation-Ver1.4-2-14-2024.pptx
blackmambaettijean
 
Chapter 3 Spatial Domain Image Processing.pdf
Getnet Tigabie Askale -(GM)
 
Dropbox Q2 2025 Financial Results & Investor Presentation
Dropbox
 
Programs and apps: productivity, graphics, security and other tools
4mqw9zch22
 
Machine learning based COVID-19 study performance prediction
IAESIJAI
 
KOM of Painting work and Equipment Insulation REV00 update 25-dec.pptx
muhammadmuneebnaeem7
 
Network Security Unit 5.pdf for BCA BBA.
Serpent6
 
Spectral efficient network and resource selection model in 5G networks
IAESIJAI
 
Teaching material agriculture food technology
LiaRayya
 
ACSFv1EN-58255 AWS Academy Cloud Security Foundations.pptx
23bcla24
 
Agricultural_Statistics_at_a_Glance_2022_0.pdf
SandeepSingh286037
 
cuic standard and advanced reporting.pdf
SimoneTitaniumTomase
 
Architecting across the Boundaries of two Complex Domains - Healthcare & Tech...
Peter Tan
 
Profit Center Accounting in SAP S/4HANA, S4F28 Col11
Libreria ERP
 
Peak of Data & AI Encore- AI for Metadata and Smarter Workflows
Safe Software
 
A comparative analysis of optical character recognition models for extracting...
IAESIJAI
 
sap open course for s4hana steps from ECC to s4
sreeni2106invites
 

07 ds and algorithm session_10

  • 1. Data Structures and Algorithms Objectives In this session, you will learn to: Identify the features of a stack Implement stacks Apply stacks to solve programming problems Ver. 1.0 Session 10
  • 2. Data Structures and Algorithms Stacks • Let us play the game of Rummy. 7 7 7 7 6 6 6 6 6 6 6 6 7 7 7 7 6 6 6 6 6 6 6 6 Ver. 1.0 Session 10
  • 3. Data Structures and Algorithms Defining a Stack A stack is Stack ? What is a a collection of data items that can be accessed at only one end, called top. Items can be inserted and deleted in a stack only at the top. The last item inserted in a stack is the first one to be deleted. Therefore, a stack is called a Last-In-First-Out (LIFO) data structure. Ver. 1.0 Session 10
  • 4. Data Structures and Algorithms Identifying the Operations on Stacks • PUSH: It two process of inserting are performed There areis thebasic operations that a new element on the top of a stacks: stack. PUSH POP Push an Element 1 Empty Stack 1 Ver. 1.0 Session 10
  • 5. Data Structures and Algorithms Identifying the Operations on Stacks (Contd.) • PUSH: It is the process of inserting a new element on the top of a stack. Push an Push an Element 2 Element 3 3 2 1 Ver. 1.0 Session 10
  • 6. Data Structures and Algorithms Identifying the Operations on Stacks (Contd.) • POP: It is the process of deleting an element from the top of a stack. POP an Element 3 3 2 2 1 Ver. 1.0 Session 10
  • 7. Data Structures and Algorithms Just a minute Elements in stacks are inserted and deleted on a ___________ basis. Answer: LIFO Ver. 1.0 Session 10
  • 8. Data Structures and Algorithms Just a minute List down some real life examples that work on the LIFO principle. Answer: Pile of books: Suppose a set of books are placed one over the other in a pile. When you remove books from the pile, the topmost book will be removed first. Similarly, when you have to add a book to the pile, the book will be placed at the top of the pile. Pile of plates: The first plate begins the pile. The second plate is placed on the top of the first plate and the third plate is placed on the top of the second plate, and so on. In general, if you want to add a plate to the pile, you can keep it on the top of the pile. Similarly, if you want to remove a plate, you can remove the plate from the top of the pile. Bangles in a hand: When a person wears bangles, the last bangle worn is the first one to be removed. Ver. 1.0 Session 10
  • 9. Data Structures and Algorithms Implementing Stacks You need to develop a method to check if the parentheses in an arithmetic expression are correctly nested. How will you solve this problem? You can solve this problem easily by using a stack. Ver. 1.0 Session 10
  • 10. Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} Consider an example. Suppose the expression is: {(a + b) × (c + d) + (c × d)]} Scan the expression from left to right. The first entry to be scanned is ‘{’, which is a left parenthesis. Push it into the stack. { Ver. 1.0 Session 10
  • 11. Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} The next entry to be scanned is ‘(’, which is a left parenthesis. Push it into the stack. The next entry is ‘a’, which is an operand. Therefore, it is discarded. The next entry is ‘+’, which is an operator. Therefore, it is discarded. ( { The next entry is ‘b’, which is an operand. Therefore, it is discarded. Ver. 1.0 Session 10
  • 12. Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} The next entry to be scanned is ‘)’, which is a right parenthesis POP the topmost entry from the stack. Match the two brackets. ( ) Brackets Matched ( { Ver. 1.0 Session 10
  • 13. Data Structures and Algorithms Implementing Stacks (Contd.) The next entry to be scanned {(a + b) × (c + d) + (c × d)]} is ‘×’, which is an operator. Therefore, it is discarded. The next entry to be scanned is ‘(’, which is a left parenthesis Push it into the stack The next entry to be scanned is ‘c’, which is an operand. Therefore it is discarded ( The next entry to be scanned { is ‘+’, which is an operator. Therefore it is discarded The next entry to be scanned is ‘d’, which is an operand. Therefore it is discarded Ver. 1.0 Session 10
  • 14. Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} The next entry to be scanned is ‘)’, which is a right parenthesis. POP the topmost element from the stack. Match the two brackets. ( ) Brackets Matched ( { Ver. 1.0 Session 10
  • 15. Data Structures and Algorithms Implementing Stacks (Contd.) The next entry to be scanned {(a + b) × (c + d) + (c × d)]} is ‘+’, which is an operator. Therefore, it is discarded. The next entry to be scanned is ‘(’, which is a left parenthesis. Push it into the stack. The next entry to be scanned is ‘c’, which is an operand. Therefore, it is discarded. ( The next entry to be scanned { is ‘×’, which is an operator. Therefore, it is discarded. The next entry to be scanned is ‘d’, which is an operand. Therefore, it is discarded. Ver. 1.0 Session 10
  • 16. Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} The next entry to be scanned is ‘)’, which is a right parenthesis. POP the topmost element from the stack. Match the two brackets. ( ) Brackets Matched ( { Ver. 1.0 Session 10
  • 17. Data Structures and Algorithms Implementing Stacks (Contd.) {(a + b) × (c + d) + (c × d)]} The next entry to be scanned is ‘]’, which is a right parenthesis. POP the topmost element from the stack. Match the two brackets. { ] Brackets Do Not Match The Expression is INVALID { Ver. 1.0 Session 10
  • 18. Data Structures and Algorithms Implementing a Stack Using an Array A stack is similarstack list in which insertion and deletion is To implement a to a using an array: allowed only atarray: end. – Declare an one Therefore,Stack[5];a // Maximum size needs to be specified in int similar to list, stack can be implemented using both arrays and linked lists. // advance – Declare a variable, top to hold the index of the topmost element in the stacks: int top; – Initially, when the stack is empty, set: top = –1 Ver. 1.0 Session 10
  • 19. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) Let us now write an algorithm for 1. Increment top by 1. the PUSH operation. 3. Store the value to be pushed at index top in Initially: the array. Top now top = – 1 contains the index of the topmost element. PUSH an element 3 0 1 2 3 4 Stack Ver. 1.0 Session 10
  • 20. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now top = – 1 contains the index of the topmost element. PUSH an element 3 0 1 2 3 4 Stack 10 Ver. 1.0 Session 10
  • 21. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now top = 0 contains the index of the topmost element. PUSH an element 3 0 1 2 3 4 Stack 10 top = 0 Ver. 1.0 Session 10
  • 22. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 3 0 1 2 3 4 Stack 3 10 Item pushed top = 0 Ver. 1.0 Session 10
  • 23. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) 1. Increment top by 1. 3. Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 8 0 1 2 3 4 Stack 3 10 top = 0 Ver. 1.0 Session 10
  • 24. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 8 0 1 2 3 4 Stack 3 10 top = 0 = 1 top Ver. 1.0 Session 10
  • 25. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 8 0 1 2 3 4 Stack 3 10 8 Item pushed top = 1 Ver. 1.0 Session 10
  • 26. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) 1. Increment top by 1. 3. Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 5 0 1 2 3 4 Stack 3 10 8 top = 1 Ver. 1.0 Session 10
  • 27. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 5 0 1 2 3 4 Stack 3 10 8 top = top = 2 1 Ver. 1.0 Session 10
  • 28. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 5 0 1 2 3 4 Stack 3 10 8 5 Item pushed top = 2 Ver. 1.0 Session 10
  • 29. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) 1. Increment top by 1. 3. Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 1 0 1 2 3 4 Stack 3 10 8 5 top = 2 Ver. 1.0 Session 10
  • 30. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 1 0 1 2 3 4 Stack 3 10 8 5 top = 2 = 3 top Ver. 1.0 Session 10
  • 31. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 1 0 1 2 3 4 Stack 3 10 8 5 1 Item pushed top = 3 Ver. 1.0 Session 10
  • 32. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) 1. Increment top by 1. 3. Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 9 0 1 2 3 4 Stack 3 10 8 5 1 top = 3 Ver. 1.0 Session 10
  • 33. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 9 0 1 2 3 4 Stack 3 10 8 5 1 top = 3 = 4 top Ver. 1.0 Session 10
  • 34. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 9 0 1 2 3 4 Stack 3 10 8 5 1 9 Item pushed top = 4 Ver. 1.0 Session 10
  • 35. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) 1. Increment top by 1. 3. Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 2 0 1 2 3 4 Stack 3 10 8 5 1 9 top = 4 Ver. 1.0 Session 10
  • 36. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 2 0 1 2 3 4 Stack 3 10 8 5 1 9 top = 4top = 5 Ver. 1.0 Session 10
  • 37. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) • Increment top by 1. • Store the value to be pushed at index top in the array. Top now contains the index of the topmost element. PUSH an element 2 0 1 2 3 4 Stack 3 10 8 5 1 9 Stack overflow top = 5 Ver. 1.0 Session 10
  • 38. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) The stack has been implemented To avoid the stack overflow, you 1. Increment top–by 1. If top = MAX 1: a. Display “Stack need to checksizethe stack full in an array of for 5. 3. Store the value to be Full” condition before pushing an element Therefore, you cannot store more pushed at index top in b. Exit the array. Top now into theelements in the stack. than 5 stack. 3. contains the index1of the Increment top by Let us modify the algorithm to check topmost element. 5. Store the value to be for this condition. pushed at index top in the array 0 1 2 3 4 Stack 3 10 8 5 1 9 Ver. 1.0 Session 10
  • 39. Data Structures and Algorithms Implementing a Stack Using an Array (Contd.) Write an algorithm to implement the POP operation on a stack. Algorithm for POP operation: 1. If top = – 1: a. Display “Stack Empty” b. Exit 4. Retrieve the value stored at index top 5. Decrement top by 1 Ver. 1.0 Session 10
  • 40. Data Structures and Algorithms Just a minute In a stack, data can be stored and removed only from one end of the stack called the ______ of the stack. Answer: top Ver. 1.0 Session 10
  • 41. Data Structures and Algorithms Implementing a Stack Using a Linked List Write an algorithm to implement theas follows: The algorithm for PUSH operation isPUSH and POP POP operation is as follows: operations using a Linkedtmp point to the topmost node. Make a memory for the List. 1. Allocatevariable/pointer new node. 2. Assign valuevalue contained in the topmost node. Retrieve the to the data field of the new node. 3. Make the next field of nextnew node point to top. top point to the the node in sequence. 4. Make topmemory allocatednode. node marked by tmp. Release point to the new to the Ver. 1.0 Session 10
  • 42. Data Structures and Algorithms Activity: Implementing a Stack Using an Array Problem Statement: Write a program to implement a stack by using an array that can store five elements. Ver. 1.0 Session 10
  • 43. Data Structures and Algorithms Activity: Implementing a Stack Using a Linked List Problem Statement: Write a program to implement a stack by using a linked list. Ver. 1.0 Session 10
  • 44. Data Structures and Algorithms Just a minute What will be the condition for stack full in a stack implemented as a linked list? Answer: When a stack is implemented as a linked list, there is no upper bound limit on the size of the stack. Therefore, there will be no stack full condition in this case. Ver. 1.0 Session 10
  • 45. Data Structures and Algorithms Just a minute If a stack is represented in memory by using a linked list, then insertion and deletion of data will be done ________. 1. At the end of the list 2. At the beginning of the list 3. Anywhere in the list 4. At the beginning and at the end of the list respectively Answer: 2. At the beginning of the list Ver. 1.0 Session 10
  • 46. Data Structures and Algorithms Applications of Stacks Some of the applications of stacks are: Implementing function calls Maintaining the UNDO list for an application Checking the nesting of parentheses in an expression Evaluating expressions Ver. 1.0 Session 10
  • 47. Data Structures and Algorithms Implementing Function Calls Implementing function calls: Consider an example. There are three functions, F1, F2, and F3. Function F1 invokes F2 and function F2 invokes F3, as shown. Ver. 1.0 Session 10
  • 48. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() Assuming these instructions at the { given locations in the memory. 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
  • 49. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() { The execution starts from 1100 int x; function F1 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
  • 50. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
  • 51. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x=5 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
  • 52. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x=5 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } Address and the local variable of F1 void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
  • 53. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x = 10 5 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
  • 54. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x = 10 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 1122, x = 10 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } Address and the local variable of F2 void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
  • 55. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x = 20 10 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 1122, x = 10 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } Address and the local variable of F2 void F3(int x) { 1140 x = x × 2; 1141 print x; } Ver. 1.0 Session 10
  • 56. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x = 20 10 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) 1122, x = 10 { 1120 1122, x = 10 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; 20 } Ver. 1.0 Session 10
  • 57. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x=5 10 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) 1103, x = 5 { 1120 x = x + 5; 1121 F3(x); 1103, x = 5 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; 20 10 } Ver. 1.0 Session 10
  • 58. Data Structures and Algorithms Implementing Function Calls (Contd.) void F1() x=5 { 1100 int x; 1101 x = 5; 1102 F2(); 1103 print(x); } void F2(int x) { 1120 x = x + 5; 1121 F3(x); 1122 print(x); } void F3(int x) { 1140 x = x × 2; 1141 print x; 20 10 5 } Ver. 1.0 Session 10
  • 59. Data Structures and Algorithms Maintaining the UNDO list for an Application Maintaining the UNDO list for an application: Consider that you made some changes in a Word document. Now, you want to revert back those changes. You can revert those changes with the help of an UNDO feature. The UNDO feature reverts the changes in a LIFO manner. This means that the change that was made last is the first one to be reverted. You can implement the UNDO list by using a stack. Ver. 1.0 Session 10
  • 60. Data Structures and Algorithms Checking the Nesting of Parentheses in an Expression Checking the nesting of parentheses in an expression: You can do this by checking the following two conditions: – The number of left parenthesis should be equal to the number of right parenthesis. – Each right parenthesis is preceded by a matching left parenthesis. Ver. 1.0 Session 10
  • 61. Data Structures and Algorithms Evaluating Expressions Evaluating an expression by using stacks: Stacks can be used to solve complex arithmetic expressions. The evaluation of an expression is done in two steps: Conversion of the infix expression into a postfix expression. Evaluation of the postfix expression. Ver. 1.0 Session 10
  • 62. Data Structures and Algorithms Activity: Implementing a Stack using a Linked List Problem Statement: Write a program that accepts an infix expression, and then converts it into a postfix expression. You can assume that the entered expression is a valid infix expression. Ver. 1.0 Session 10
  • 63. Data Structures and Algorithms Summary In this session, you learned that: A stack is a collection of data items that can be accessed at only one end, called top. The last item inserted in a stack is the first one to be deleted. A stack is called a LIFO data structure. There are two operations that can be performed on stacks. They are: – PUSH – POP – Stacks can be implemented by using both arrays and linked lists. Ver. 1.0 Session 10
  • 64. Data Structures and Algorithms Summary (Contd.) Stacks are used in many applications. Some of the application domains of stacks are as follows: Implementing function calls Maintaining the UNDO list for an application Checking the nesting of parentheses in an expression Evaluating expressions Ver. 1.0 Session 10

Editor's Notes

  • #3: To start the session, you need to get a set of playing cards in the class. Follow the instructions as given below to begin the game of Rummy. 1. The game begins by dealing a fixed number of cards to all players. The remaining cards are placed face down to form a “stock” pile. 2. There is also a face-up pile called the “discard” pile. 3. Initially, the discard pile contains only one card which is obtained by picking the topmost card from the stock pile. 4. Each player can draw either the topmost card of the stock pile or the topmost card on the discard pile to make a valid sequence in his/her hand. 5. After this, the player must discard one card on top of the discard pile. 6. The next player, can then draw either the topmost card of the draw pile or the topmost card of the discard pile. 7. Therefore, if a player has to draw a card from the discard pile, he/she can draw only the topmost card of the discard pile. 8. Similarly, when a player has to discard a card, he/she must discard it on the top of the discard pile. 9. The discard pile can therefore be considered a Last-In-First-Out list. 10. The last card placed on top of the discard pile is the first one to be drawn. 11. To represent and manipulate this kind of a discard pile in a computer program, you would like to use a list that: a. Contains the details of all the cards in the discard pile. b. Implements insertion and deletion of card details in such a way that the last inserted card is the first one to be removed. This kind of a list can be implemented by using a stack. Ask students to define a stack? Ask them to refer to the game and come up with some characteristics of a stack. Then come to next slide and give them the definition of stacks.
  • #5: You can give some more explanation of stacks by with the help of the following example. 1. A stack is like an empty box containing books, which is just wide enough to hold the books in one pile. 2. The books can be placed as well as removed only from the top of the box. 3. The book most recently put in the box is the first one to be taken out. 4. The book at the bottom is the first one to be put inside the box and the last one to be taken out.
  • #8: In this slide you need to show the calculation to determine the sum of an arithmetic progression for bubble sort algorithm. Refer to student guide.
  • #9: In this slide you need to show the calculation to determine the sum of an arithmetic progression for bubble sort algorithm. Refer to student guide.
  • #10: This is one of the applications where stack is used. You need to run through the slides and then ask students to write an algorithm to check the correctness of the nested parenthesis. The algorithm will be: Scan the expression. Push the opening bracket into the stack. If a closing bracket is encountered, check if the closing bracket is same as the opening bracket. If this condition holds true, POP the corresponding opening bracket from the stack. If the condition is false, the expression is not a valid expression.
  • #19: Tell students that stacks can be implemented using both arrays and Linked List. The slides to explain the implementation of stacks using an array are given.
  • #40: Make this session an interactive one by asking students to write an algorithm to implement POP operation using an array. Let students first try to write the algorithm. Then you can explain the algorithm given in the student guide. In addition, also explain the exception conditions that is encountered while popping an element from the stack, using an array.
  • #41: In this slide you need to show the calculation to determine the sum of an arithmetic progression for bubble sort algorithm. Refer to student guide.
  • #42: Student have learnt the implementation of Linked List in chapter 2, therefore ask students to write an algorithm for the PUSH and POP operations using linked lists.
  • #43: To demonstrate this activity, you do not need to write the complete code. You can use the data files provided at the following location. TIRM  Datafiles for Faculty  Chapter 06  Activities  StackUsingArrays_CSharp.txt and TIRM  Datafiles for Faculty  Chapter 06  Activities  StackUsingArrays_CPP.txt .
  • #44: To demonstrate this activity, you do not need to write the complete code. You can use the data files provided at the following location. TIRM  Datafiles for Faculty  Chapter 06  Activities  StackUsingLinkedList_CSharp.txt and TIRM  Datafiles for Faculty  Chapter 06  Activities  StackUsingLinkedList_CPP.txt .
  • #45: In this slide you need to show the calculation to determine the sum of an arithmetic progression for bubble sort algorithm. Refer to student guide.
  • #46: In this slide you need to show the calculation to determine the sum of an arithmetic progression for bubble sort algorithm. Refer to student guide.
  • #47: In this section, you need to discuss the applications of Stacks. In addition, to the given applications, you can discuss some real life applications also. For example, ask students to notice the operations in their Mobile phones. When you go to the Menu  log  Recent calls  Missed calls. On the missed call page, you will be able to view all the missed call number. To back to the main page, you need to press the back option and it will take you page, you last visited.
  • #48: In this section, you need to discuss the applications of Stacks. In addition, to the given applications, you can discuss some real life applications also. For example, ask students to notice the operations in their Mobile phones. When you go to the Menu  log  Recent calls  Missed calls. On the missed call page, you will be able to view all the missed call number. To back to the main page, you need to press the back option and it will take you page, you last visited.
  • #60: Explain this concept to students by further telling them that the changes are internally stored in the stack data structure inside the computer. The last change made is the first one to be reverted.
  • #61: In this slide, ask students to relate to the example they have learnt in the beginning of the session.
  • #62: In this slide, ask students to relate to the example they have learnt in the beginning of the session.
  • #63: To demonstrate this activity, you do not need to write the complete code. You can use the data files provided at the following location. TIRM  Datafiles for Faculty  Chapter 06  Activities  InfixToPostfix_CSharp.txt and TIRM  Datafiles for Faculty  Chapter 06  Activities  InfixToPostfix_CPP.txt .