A stack is a data structure that operates on a last in, first out (LIFO) principle, allowing insertion and deletion at one end called the top. Stack operations include push, pop, top, size, isempty, and isfull, and it can be implemented using arrays or linked lists, each with its advantages and disadvantages. The document also outlines various applications of stacks such as balancing symbols, expression evaluation, and managing function calls.

1. STACK DATA STRUCTURE

2. WHAT IS A DATA STRUCTURE
• Data Structure is a way to store and organize data so that
it can be used efficiently.
• It is a special format for organizing and storing data.
• Data Structures
• Linear Structure
• Linked List
• Stack
• Queue
• Non Linear Structure
• Graph
• Tree

3. ABSTRACT DATA TYPES
• To simplify process of problem solving, we combine
data structure with their operations and call this
Abstract Data Types (ADT)
• It consists of 2 parts
• Declaration of Data
• Declaration of Operations

4. WHAT IS STACK
• A stack is an ordered list
in which insertion and
deletion are done at one
end, called top.
• The last element inserted
is the first one to be
deleted.
• Hence it is called Last In
First Out(LIFO) or First In
Last Out(FILO).

5. STACK ADT
Stack
Main Stack
Operations
push (int data)
int pop()
Auxiliary Stack
Operations
int top()
int size()
int isEmpty()
int isFull()

6. STACK OPERATIONS
Operation Description
push(int data) inserts data into stack
int pop() removes and returns last inserted
element
int top() returns last inserted element
int size() returns number of elements in stack
int isEmpty() indicate if any element is stored or not
int isFull() indicates if stack is full or not

7. STACK APPLICATIONS
• Balancing of Symbols
• Infix to Postfix conversion
• Evaluation of postfix expression
• Implementing function calls
• History of a web browser
• Undo Sequence
• Tree Traversal

8. WORKING
TOP = 0
MAX = 5
10
TOP = 1
MAX = 5
CREATE STACK
SIZE 5
PUSH(10)

9. WORKING
10
20
TOP = 2
MAX = 5
10
20
30
TOP = 3
MAX = 5
PUSH(30)
PUSH(20)

10. WORKING
10
20
30
40
TOP = 4
MAX = 5
10
20
30
TOP = 3
MAX = 5
POP()
PUSH(40)

11. WORKING
10
20
TOP = 2
MAX = 5
10
TOP = 1
MAX = 5
POP()
POP()

12. WORKING
TOP = 0
MAX = 5
FULLSTACK()
EMPTYSTACK()
10
20
30
40
50
TOP = 4
MAX = 5

13. IMPLEMENTATION BY ARRAY
• Advantages
• Best Performance
• Disadvantages
• Fixed Size
• Basic Implementation
• Initially Empty Array
• Field to record where next data is placed
• if array is full, push(item) else return false
• if array is empty, pop() return item on top else NULL

14. IMPLEMENTATION BY ARRAY
• CREATING STRUCTURE
• struct ArrayStruct{
• int top; //Keep track of top Element
• int capacity; //capacity of the stack
• int *array; //pointer to address of first index
• }
• Space Complexity (for n operations)– O(n)

15. IMPLEMENTATION BY ARRAY
• isEmpty(){
• return (S->top == -1);
• }
• Time Complexity
• O(1)
• isFull(){
• return(S->top==S->capacity-
1);
• }
• Time Complexity
• O(1)

16. IMPLEMENTATION BY ARRAY
• void push(struct Array *S,int
data){
• if(isFull(S))
• cout<<“FULL”;
• else
• S->array[++S->top]=data;
• }
• Time Complexity
• O(1)
• int pop(struct Array *S){
• if(isEmpty(S)){
• cout<<“EMPTY”;
• return;}
• else
• return (S->array[S->top]);
• }
• Time Complexity
• O(1)

17. LINKED LIST IMPLEMENTATION
• Advantages
• Always constant time to push and pop
• can grow to an infinite size
• Disadvantages
• can grow to infinite size
• common case is slowest of all
• Basic Implementation
• Initially Empty List
• push() add item on top
• pop() removes item on top

18. LINKED LIST IMPLEMENTATION
• void push(struct node **top,int d){
• struct node *temp;
• temp->data=d;
• temp->link=(*top);
• *temp = temp;
• }
• Time Complexity
• O(1)
• void pop(struct node **top){
• struct node *temp; int i;
• temp=(*top);
• i=temp->data;
• *top = (*top)->link;
• return i;
• }
• Time Complexity
• O(1)

19. USE OF STACK
EVALUATING POSTFIX = 123*+5-
Stack
Expressio
n
STEP 1
2
3
1
Stack
Expressio
n
STEP 2

20. USE OF STACK
EVALUATING POSTFIX = 123*+5-
1
Stack
Expressio
n
2*3=6
STEP 3
6
1
Stack
Expressio
n
STEP 4

21. USE OF STACK
EVALUATING POSTFIX = 123*+5-
Stack
Expressio
n
1+6=7
STEP 5
7
Stack
Expressio
n
STEP 6

22. USE OF STACK
EVALUATING POSTFIX = 123*+5-
5
7
Stack
Expressio
n
STEP 7
Stack
Expressio
n
7-5=2
STEP 8

23. USE OF STACK
EVALUATING POSTFIX = 123*+5-
2
Stack
Expressio
n
STEP 9
123*+5-
RESULT
POSTFIX STRING
2

24. REFERENCES
• Data Structures and Algorithms, Narsimha
Karumanchi
• https://www.geeksforgeeks.org/stack-data-structure/
• https://www.geeksforgeeks.org/tag/data-structures-
stack/