TOPIC:

STACK IMPLEMENTATION USING

LINKED LIST

By ADRIZA DEY
Roll No. : 11500123018
Introduction to
Stacks
In the realm of computer science, stacks are fundamental data
structures that play a crucial role in various algorithms and
applications. They are often described as a linear data structure
that follows the Last-In, First-Out (LIFO) principle. Imagine a
stack of books - the last book placed on top is the first one you
remove. This principle governs the operations and behavior of
stacks, making them a powerful tool for organizing data in a
specific order.
ACKNOWLEDGEMENT
I would like to extend my sincere gratitude to Mr. Pratap Chandra Mondal Sir, whose guidance and insightful
feedback were invaluable throughout the preparation of this project. Your expertise and encouragement have greatly
enhanced the quality of this work.

I am also grateful to our classmates and peers for their constructive criticism and support during our collaborative
sessions. Your perspectives have been essential in refining and improving the content presented here.
What is a Stack?
A stack is a linear data structure that follows the Last-In, First-Out (LIFO) principle. Think of it
like a stack of plates – the last plate placed on top is the first one you remove. This means that
the element added most recently is the first one to be removed. Stacks are characterized by
their specific operations, primarily push and pop, which allow for adding and removing
elements from the top of the stack, respectively.

1 LIFO
The Last-In, First-Out (LIFO) principle ensures that the most recently added element is
the first one to be removed.

2 Linear Data Structure

Stacks are linear data structures, meaning elements are arranged in a sequential order,
similar to a list or array.

3 Restricted Access
Elements in a stack can only be accessed and modified from the top. This restriction
ensures the LIFO principle is maintained.
Advantages of Stacks
Stacks offer a range of benefits that make them suitable for various applications in computer science and software
development. Their primary advantage lies in their efficient handling of data, particularly in scenarios where a
Last-In, First-Out (LIFO) order is desired.

Simple Implementation Efficient Operations Versatile Applications

Stacks are relatively easy to Operations like push and pop are Stacks find applications in
implement using arrays or linked highly efficient, with a constant numerous areas, including
lists, making them accessible for time complexity of O(1) in most function call management,
developers of all levels. implementations. expression evaluation, and
undo/redo functionality in
software.
Disadvantages of Stacks
While stacks offer numerous advantages, they also have some limitations that
should be considered when choosing them for a particular application. These
disadvantages are primarily related to the restricted access and fixed order of
elements within a stack.

Limited Access
Elements in a stack can only be accessed or modified from the top. This
restriction makes it challenging to access elements in the middle or at the
bottom of the stack.

Fixed Order
The Last-In, First-Out (LIFO) principle enforces a specific order for
accessing elements, which may not be suitable for all applications.
Stack Operations
Stacks are characterized by a set of essential operations that define their functionality and allow for manipulation of the
data they store. These operations are crucial for managing the elements within the stack and ensuring its integrity.

Push 1
The push operation adds a new element to the
top of the stack, effectively expanding the
stack by one element. 2 Pop
The pop operation removes the top element
from the stack, reducing the stack size by one
Peek 3 and returning the removed element.
The peek operation returns the top element of
the stack without removing it. This allows you
to inspect the top element without modifying IsEmpty
the stack.
4
The isEmpty operation checks if the stack is
empty. It returns true if the stack has no

Size elements and false otherwise.

5
The size operation returns the number of
elements currently in the stack. This allows
you to determine the stack's current size.
Implementing Stacks using Arrays
Implementing a stack using an array involves utilizing an array to store the stack elements. The array acts as a container
for the elements, and a variable, often called top, tracks the index of the top element in the array. This approach
provides a straightforward method for managing stack operations.

Initialization
Declare an array to hold the stack elements and initialize the top variable to -1, indicating an empty stack.

Push
Increment the top variable to the next available index in the array. Place the new element at the index
indicated by the top variable.

Pop
Check if the stack is empty. If not, return the element at the index pointed to by the top variable and
decrement the top variable.

Peek
Check if the stack is empty. If not, return the element at the index pointed to by the top variable without
modifying the top variable.
Implementing Stacks using Linked Lists

Implementing a stack using a linked list provides an alternative approach to managing stack
operations. In this approach, each node in the linked list represents a stack element. The top of the
stack is maintained by a reference to the head node of the linked list. This structure allows for
dynamic resizing as elements are added or removed.

Implementation Array Linked List

Data Structure Fixed-size container Dynamically sized nodes

Push Operation Append to the end of the Create a new node and
array insert at the head

Pop Operation Remove the last element Remove the head node
from the array

Memory Usage Fixed memory allocation Dynamic memory allocation

Push Operation in Linked List Stack
The push operation in a linked list stack involves adding a new element to the top of the stack. This
operation dynamically expands the stack by creating a new node in the linked list and inserting it at
the head.

Create a New Node

Create a new node in the linked list and assign the new element to its data field.

Set Next Pointer

Set the next pointer of the new node to the current head of the linked list, effectively linking the new
node to the rest of the stack.

Update Head
Update the head of the linked list to point to the newly created node, making it the top of the stack.
Pop Operation in Linked List Stack
The pop operation in a linked list stack involves removing the top element from the stack, effectively shrinking the stack
by one element. This operation removes the head node of the linked list, maintaining the LIFO principle.

Before Pop After Pop

The linked list represents the stack before the pop The head node is removed, effectively removing the top
operation. The head node is the top of the stack. element from the stack. The linked list now points to the
next node, which is the new top of the stack.
Time and Space Complexity Analysis
Stacks implemented using linked lists offer a dynamic and flexible approach to data management, with advantages in
terms of memory usage and operation efficiency. Understanding the time and space complexity of stack operations
provides valuable insights into the performance characteristics of linked list stacks.

Push Operation Pop Operation Space Complexity

The push operation in a linked Similar to the push operation, The space complexity of a
list stack has a time complexity the pop operation in a linked list linked list stack is proportional
of O(1) because it involves stack has a time complexity of to the number of elements in
creating a new node and O(1) because it only requires the stack. Each element
updating pointers, which are updating the head pointer, a requires a node to be allocated
constant-time operations. constant-time operation. in memory, resulting in a space
complexity of O(n), where n is
the number of elements.
Uses of Stack using Linked List
• Dynamic Memory Allocation: Linked list stacks can dynamically allocate memory as needed, making them
suitable for applications with variable memory requirements.

• Efficient Insertions and Removals: The push and pop operations in a linked list stack have a time
complexity of O(1), allowing for fast and efficient stack management.

• Adaptive Size: Linked list stacks can grow and shrink in size as elements are added or removed, providing a
more flexible data structure compared to fixed-size arrays.
Conclusion
In summary, stacks implemented using linked lists offer a
dynamic and flexible approach to data management. They
provide efficient push and pop operations, as well as adaptive
memory usage, making them suitable for a variety of
applications.