Lecture 04: Stack ADT CS221: Data Structures & Algo.
Stack ADT
Dr. Zahid Halim
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Stacks
“A Stack is a special kind of list in which all insertions and
deletions take place at one end, called the Top”
Other Names
Pushdown List
Last In First Out (LIFO)
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Stacks
Examples:
Books on a floor
Dishes on a shelf
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Common Operations on Stacks
1. MAKENULL(S): Make Stack S be an empty stack.
2. TOP(S): Return the element at the top of stack S.
3. POP(S): Remove the top element of the stack.
4. PUSH(S): Insert the element x at the top of the stack.
5. ISEMPTY(S): Return true if S is an empty stack; return false otherwise.
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Static and Dynamic Stacks
• There are two kinds of stack data structure -
– a) static, i.e. they have a fixed size, and are implemented as arrays.
– b) dynamic, i.e. they grow in size as needed, and implemented as
linked lists
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Push and Pop operations of Stack
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
An Array Implementation of Stacks
First Implementation
Elements are stored in contiguous cells of an array.
New elements can be inserted to the top of the list.
top First Element
Second Element
List
Last Element
Empty
maxlength
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
An Array Implementation of Stacks
1
3
2
2
1
Problem with this implementation
Every PUSH and POP requires moving the entire array up and down.
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
An Array Implementation of Stacks
Since, in a stack the insertion and deletion take place only at
the top, so…
A better Implementation:
Anchor the bottom of the stack at the bottom of the
array
Let the stack grow towards the top of the array
Top indicates the current position of the first stack
element.
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
An Array Implementation of Stacks
A better Implementation:
top
1 First Element
2 Second Element
.
.
maxlength Last Element
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
A Stack Class
#ifndef INTSTACK_H
#define INTSTACK_H
class IntStack
{
private:
int *stackArray;
int stackSize;
int top;
public:
IntStack(int);
void push(int);
void pop(int &);
bool isFull(void);
bool isEmpty(void);
};
#endif
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Implementation
//*******************
// Constructor *
//*******************
IntStack::IntStack(int size)
{
stackArray = new int[size];
stackSize = size;
top = -1;
}
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Push
// Member function push pushes the argument onto *
// the stack. *
void IntStack::push(int num)
{
if (isFull())
cout << "The stack is full.\n";
else
{
top++;
stackArray[top] = num;
}
}
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
// Member function pop pops the value at the top
// of the stack off, and copies it into the variable
// passed as an argument.
void IntStack::pop(int &num)
{
if (isEmpty())
cout << "The stack is empty.\n";
else
{
num = stackArray[top];
top--;
}
}
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
//***************************************************
// Member function isFull returns true if the stack *
// is full, or false otherwise. *
//***************************************************
bool IntStack::isFull(void)
{
bool status;
if (top == stackSize - 1)
status = true;
else
status = false;
return status;
}
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
//**********************************************
// Member funciton isEmpty returns true if the
//stack *
// is empty, or false otherwise.*
//***********************************************
bool IntStack::isEmpty(void)
{
bool status;
if (top == -1)
status = true;
else
status = false;
return status;
}
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
// This program demonstrates the IntStack class.
#include <iostream.h>
#include "intstack.h“
void main(void)
{
IntStack stack(5);
int catchVar;
cout << "Pushing 5\n";
stack.push(5);
cout << "Pushing 10\n";
stack.push(10);
cout << "Pushing 15\n";
stack.push(15);
cout << "Pushing 20\n";
stack.push(20);
cout << "Pushing 25\n";
stack.push(25);
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
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;
stack.pop(catchVar);
cout << catchVar << endl;
}
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Program Output
Pushing 5
Pushing 10
Pushing 15
Pushing 20
Pushing 25
Popping...
25
20
15
10
5
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
About Program 1
• In the program, the constructor is called with the
argument 5. This sets up the member variables as
shown in Figure 1. Since top is set to –1, the stack is
empty
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
• Figure 3 shows the state of the member variables after all five
calls to the push function. Now the top of the stack is at element
4, and the stack is full.
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Notice that the pop function uses a reference
parameter, num.
The value that is popped off the stack is copied into
num so it can be used later in the program.
Figure 4 (on the next slide) depicts the state of
the class members, and the num parameter, just
after the first value is popped off the stack.
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Implementing other Stack Operations
More complex operations can be built on the basic stack class we
have just described, e.g. a class called MathStack.
MathStack has 2 member functions :- add( ) sub( )
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Stack Templates
The stack class so far work with integers only. A stack template
can be used to work with any data type.
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
A Linked-List Implementation of Stacks
• Stack can expand or shrink with each PUSH or POP operation.
• PUSH and POP operate only on the header cell and the first
cell on the list.
Top
x y z .
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Linked List Implementation of Stack
class Stack
{
struct node
{
int data;
node *next;
};
node *top;
public:
void Push(int newelement);
int Pop(void);
bool IsEmpty();
};
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
1. void Stack::Push(int newelement)
2. {
3. node *newptr;
4. newptr=new node;
5. newptr->data=newelement;
6. newptr->next=top;
7. top=newptr;
8. }
9. int Stack:Pop(void)
10. {
11. if (IsEmpty()) { cout<<“underflow error”; return;}
12. tempptr=top;
13. int returnvalue=top->data;
14. top=top->next;
15. delete tempptr;
16. return returnvalue;
17. }
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
void Stack::IsEmpty()
{
if (top==NULL) return true;
else return false;
}
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
Program 3
// This program demonstrates the dynamic stack
// class DynIntClass.
#include <iostream.h>
#include "dynintstack.h“
void main(void)
{
DynIntStack stack;
int catchVar;
cout << "Pushing 5\n";
stack.push(5);
cout << "Pushing 10\n";
stack.push(10);
cout << "Pushing 15\n";
stack.push(15);
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT CS221: Data Structures & Algo.
cout << "Popping...\n";
stack.pop(catchVar);
cout << catchVar << endl;
stack.pop(catchVar);
cout << catchVar << endl;
stack.pop(catchVar);
cout << catchVar << endl;
cout << "\nAttempting to pop again... ";
stack.pop(catchVar);
}
Program Output
Pushing 5
Pushing 10
Pushing 15
Popping...
15
10
5
Attempting to pop again... The stack is empty.
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
Lecture 04: Stack ADT Quiz 1 CS221: Data Structures & Algo.
Q1. Given two data structures Alpha and Beta and a set of operation
insertion, deletion and searching with the percentage of occurrence of
each as 70%, 10% and 20 %. Which one of the two data structures
(Alpha and Beta) will you be selecting and why.
Q2. What is the time complexity of following code:
•delNodeDoubly()
•{
•IntList *ptrCurrent=ListHeadPtr;
• while (ptrCurrent!=NULL && ptrCurrent->data!=key)
• { ptrCurrent = ptrCurrent->next;
• }
• if (ptrCurrent == NULL)
• { cout<<"\nElement to delete not found in the list";
• return;
• }
• if (ptrCurrent == ListHeadPtr) //node to delete is first node
• {
• ListHeadPtr = ListHeadPtr->next;
• ListHeadPtr->previous = NULL; }
Ghulam Ishaq Khan Institute of Engineering Sciences and Technology, Topi
