CS-2001
Data Structures
Fall 2022
Introduction to Stack ADT
Mr. Muhammad Usman Joyia
National University of Computer
and Emerging Sciences,
Faisalabad, Pakistan.
1
Roadmap
Previous Lecture
• Variations of linked lists
– Doubly linked lists
– Circular Linked lists
Today
• Introduction to Stack
– Common applications
– Array Based-Implementation
– Linked-list Based Implementation
2
Stack
• A structure consisting of homogeneous elements and:
– Insertion and deletions takes place at one end called top
– It is a commonly used abstract data type with two major
operations, namely push and pop.
• Other names
– Last In First Out (LIFO) Structure
– First In Last Out (FILO) Structure
3
Real life scenarios…
• Books on floor
• Dishes on a shelf
• In programming, consider doing X = (A+B) * (C+D)
4
Stack ADT Operations
• Stack ADT emphasizes specific operations
– Uses an explicit linear ordering (Random access is
intentionally revoked)
– Insertions and removals are performed individually.
– Inserted objects are pushed onto the stack
– Top of the stack is the most recent object pushed onto the
stack
– Push and pop operations changes the current top value of the
stack
5
Stack ADT – Operations (1)
• Graphically, the stack operations are viewed as follows:
6
Stack ADT – Operations (2)
• CreateStack(S)
– Make Stack S be an empty stack
• Top(S)
– Return the element at the top of stack S
• Pop(S)
– Remove the top element of the stack
• Push(S,x)
– Insert the element x at the top of the stack
• Empty(S)
– Return true if S is an empty stack and return false otherwise
7
Push and Pop Operations of Stack
8
Applications (1)
• Many applications
– Parsing code
Matching parenthesis problem
– Tracking function calls (Call stack)
– Reversing a string
– Infix to postfix Conversion
– Backtracking in Depth-First-Search
• The stack is a very simple data structure
– Given any problem, if it is possible to use a stack, this
significantly simplifies the solution
9
Use of Stack in Function Calls (1)
• When a function begins execution an activation record is
created to store the current execution environment for that
function
• Activation records all the necessary information about a
function call, including
– arguments passed by the caller function
– Local variables
– Content of the registers
– Return address to the caller function
Address of instruction following the function call
11
Use of Stack in Function Calls (2)
• Each invocation of a function has its own activation record
• Recursive/Multiple calls to the functions require several
activation records to exist simultaneously
• A function returns only after all functions it calls have
returned Last In First Out (LIFO) behavior
• A program/OS keeps track of all the functions that have
been called using run-time stack or call stack
12
Runtime Stack Example (1)
void main(){
int a=3;
f1(a); // statement A
cout << endl;
}
void f1(int x){
cout << f2(x+1); // statement B
}
int f2(int p){
int q=f3(p/2); // statement C
return 2*q;
}
int f3(int n){
return n*n+1;
}
13
Runtime Stack
• When a function is called …
– Copy of activation record pushed onto run-time stack
– Arguments copied into parameter spaces
– Control is transferred to starting address of body of function
Function
Return Local
Parameter value
value variables Return
s address
OS denotes that when execution of main() is
completed, it returns to the operating system
14
Runtime Stack Example (2)
void main(){
int a=3;
f1(a); // statement A
cout << endl;
}
void f1(int x){
cout << f2(x+1); // statement B
}
int f2(int p){
int q=f3(p/2); // statement C
return 2*q;
}
int f3(int n){
return n*n+1;
}
15
Static and Dynamic Stacks
• Two possible implementations of stack data structure
– Static, i.e., fixed size implementation using arrays
– Dynamic implementation using linked lists
16
Array-based Implementation
17
Array Implementation – First Solution (1)
• Elements are stored in contiguous cells of an array
• New elements can be inserted to the top of the list
top last-pushed
Element
Second-last
Element List
1st pushed
Element
Empty
maxlengt
h
18
Array Implementation – First Solution (2)
1
3
2
2
1
1
• Problem
– Every PUSH and POP requires moving the entire array up and
down
– Fixed size 19
Array Implementation – Tweaked Solution (2)
1 1st pushed Element
2 2nd -pushed List
Element
…
top Last-pushed
Element
Empty
maxlengt
h
Idea
• Anchor the bottom of the stack at the start of the array
• Let the stack grow towards the last of the array
• Top indicates the current position of the recently inserted
stack element
20
Array Implementation – Code (1)
class IntStack
{
private:
int *stackArray;
int stackSize;
int top;
public:
IntStack(int);
~IntStack( );
bool push(int);
bool pop(int &);
bool isFull();
bool isEmpty();
};
21
Array Implementation – Code (2)
• Constructor
IntStack::IntStack(int size) //constructor
{
stackArray = new int[size];
stackSize = size;
top = -1;
}
• Destructor
IntStack::~IntStack(void) //destructor
{
delete [] stackArray;
}
22
Array Implementation – Code (3)
• isFull function
bool IntStack::isFull(void)
{
if (top == stackSize - 1)
return true;
else
return false;
// return (top == stackSize-1);
}
• isEmpty function
bool IntStack::isEmpty(void)
{
return (top == -1);
}
23
Array Implementation – Code (4)
• push function inserts the argument num onto the stack
bool IntStack::push(int num)
{
if (isFull())
{
cout << "The stack is full.\n";
return false;
}
top++;
stackArray[top] = num;
return true;
}
24
Array Implementation – Code (5)
• Pop function removes the value from top of the stack and
returns it as a reference
bool IntStack::pop(int &num)
{
if (isEmpty())
{
cout << "The stack is empty.\n";
return false;
}
num = stackArray[top];
top--;
return true;
}
25
Using Stack (1)
int main()
{
IntStack stack(4);
stackArra [0] top -1
y [1]
stackSize 4
[2
][3
]
}
26
Using Stack (2)
int main()
{
IntStack stack(4);
int catchVar;
cout << "Pushing Integers\n";
stack.push(5);
stack.push(10);
stack.push(15); stackArra 5 [0] top 3
stack.push(20); y [1]
1
stackSize 4
0
1 [2
5 ][3
2
0 ]
}
27
Using Stack (3)
int main()
{
IntStack stack(4); num 20
int catchVar;
cout << "Pushing Integers\n";
stack.push(5);
stack.push(10);
stack.push(15); stackArra 5 [0] top 2
stack.push(20); y [1]
1
stackSize 4
cout << "Popping...\n"; 0
1 [2
stack.pop(catchVar); 5 ][3
cout << catchVar << endl;
]
}
28
Using Stack (4)
int main()
Output:
{
IntStack stack(4); Pushing Integers
int catchVar; Popping…
20
cout << "Pushing Integers\n"; 15
stack.push(5); 10
stack.push(10);
stack.push(15);
5
stack.push(20);
cout << "Popping...\n";
stack.pop(catchVar);
cout << catchVar << endl;
stack.pop(catchVar);
cout << catchVar << endl;
stack.pop(catchVar);
cout << catchVar << endl;
stack.pop(catchVar);
cout << catchVar << endl;
return 0;
}
29
Any Question So Far?
37
