stack_presentaton_HUSNAIN[2].pojklklklptx

2
Name Syed Husnain Naqvi
Roll no 05
Presented By
Presentation on the topic stack
University of Kotli Azad Jammu and Kashmir
Subject Data structures and Algorithms
Department Data Science
Session 2022-26
Faculty Computing and Engineering

Introduction to stack
Stack is a linear data structure with a pre-defined capacity, which means that it can store the elements of a
limited size. It is a data structure that follows some order to insert and delete the elements, and that order
can be LIFO or FILO.
• Stack is a data structure in which data is added and removed at only one end called the top.
• To add (push) an item to the stack, it must be placed on the top of the stack.
• To remove (pop) an item from the stack, it must be removed from the top of the stack too.
• Thus, the last element that is pushed into the stack, is the first element to be popped out of the stack.
4

An Example of Stack
2
8
1
7
2
7
2
1
7
2
1
7
2
8
1
7
2
8
1
7
2
top
top
top
top
top
top
Push(8) Push(2)
pop()
pop(8)
pop(1)
5

Stack ADT (abstract data type)
A stack is an abstract data type that serves as a collection of
elements with different operations.
• Push, which adds an element to the collection.
• Pop, which removes the element.
• full/empty, which determine the stack is full or empty.
7

Applications of Stacks:
•Function calls: Stacks are used to keep track of the return addresses of
function calls, allowing the program to return to the correct location after a
function has finished executing.
•Recursion: Stacks are used to store the local variables and return addresses of
recursive function calls, allowing the program to keep track of the current state of
the recursion.
•Expression evaluation: Stacks are used to evaluate expressions in postfix
notation (Reverse Polish Notation).
•Syntax parsing: Stacks are used to check the validity of syntax in programming
languages and other formal languages.
•Memory management: Stacks are used to allocate and manage memory in
some operating systems and programming languages.
8

Advantages of Stacks
•Simplicity: Stacks are a simple and easy-to-understand data structure,
making them suitable for a wide range of applications.
•Efficiency: Push and pop operations on a stack can be performed in
constant time (O(1)), providing efficient access to data.
•Last-in, First-out (LIFO): Stacks follow the LIFO principle, ensuring that the
last element added to the stack is the first one removed. This behavior is
useful in many scenarios, such as function calls and expression evaluation.
•Limited memory usage: Stacks only need to store the elements that have
been pushed onto them, making them memory-efficient compared to other
data structures.
9

Disadvantages of Stacks
•Limited access: Elements in a stack can only be accessed from the
top, making it difficult to retrieve or modify elements in the middle of the
stack.
•Potential for overflow: If more elements are pushed onto a stack
than it can hold, an overflow error will occur, resulting in a loss of data
•.
•Not suitable for random access: Stacks do not allow for random
access to elements, making them unsuitable for applications where
elements need to be accessed in a specific order.
•Limited capacity: Stacks have a fixed capacity, which can be a
limitation if the number of elements that need to be stored is unknown
or highly variable.
10

Implementation of stack
Two implementations in stack is:
• Stack As Array
• Stack As Linked List
11

Representation of a Stack as a array
We are given a stack of elements: 12 , 08 , 21 , 33 , 18 , 40.
12

Representation of a Stack as a array
We are given a stack of elements: 12 , 08 , 21 , 33 , 18 , 40.
13

In an array-based implementation.
The push operation is implemented by incrementing the index of the top
element and storing the new element at that index.
public void push(Object object){
if (count == array.length)
throw new ContainerFullException();
else
array[count++] = object;
}
Push() method adds an element at the top the stack.
It takes as argument an Object to be pushed.
It first checks if there is room left in the stack. If no room is left, it throws a
ContainerFullException exception. Otherwise, it puts the object into the array, and
then increments count variable by one.
14

The pop operation is implemented by storing the element at the top, decrementing
the index of the top element and returning the value stored.
public Object pop(){
if(count == 0)
throw new ContainerEmptyException();
else {
Object result = array[--count];
array[count] = null;
return result;
}
}
The pop method removes an item from the stack and returns that item.
The pop method first checks if the stack is empty. If the stack is empty, it throws a
ContainerEmptyException. Otherwise, it simply decreases count by one and returns
the item found at the top of the stack
15

getTop() method first checks if the stack is empty.
getTop() method is a stack accessor which returns the top item in the stack
without removing that item. If the stack is empty, it throws a
ContainerEmptyException. Otherwise, it returns the top item found at
position count-1.
public Object getTop(){
if(count == 0)
throw new ContainerEmptyException();
else
return array[count – 1];
}
16

Representation of a Stack as a Linked List
A Linked List is a Data Structure which
consists of two parts:
•The data/value part.
•The pointer which gives the location of the
next node in the list.
17

Difference between array and link list
19

stack_presentaton_HUSNAIN[2].pojklklklptx

More Related Content

Similar to stack_presentaton_HUSNAIN[2].pojklklklptx (20)

Recently uploaded (20)

stack_presentaton_HUSNAIN[2].pojklklklptx