Basic Operations in Stack Data Structure with Implementations
Last Updated : 03 Nov, 2024
In order to make manipulations in a stack, there are certain operations provided to us for Stack, which include:
- push() to insert an element into the stack
- pop() to remove an element from the stack
- top() Returns the top element of the stack.
- isEmpty() returns true if the stack is empty else false.
- size() returns the size of the stack.
In this post, we will see how to perform these operations on Stack.
Push Operation in Stack:
Push operation adds an item to the stack.
If the stack is full, then it is said to be an Overflow condition.
Below is a sample program to show Push operation in Stack.
C++ #include <bits/stdc++.h> using namespace std; int main() { stack<int> s; // creating a stack of integers s.push(1); // This pushes 1 to the stack top s.push(2); // This pushes 2 to the stack top s.push(3); // This pushes 3 to the stack top s.push(4); // This pushes 4 to the stack top s.push(5); // This pushes 5 to the stack top // printing the stack while (!s.empty()) { cout << s.top() << " "; s.pop(); } // The above loop prints "5 4 3 2 1" } import java.util.ArrayDeque; public class StackExample { public static void main(String[] args) { ArrayDeque<Integer> s = new ArrayDeque<>(); s.push(1); // Pushing 1 to the top s.push(2); // Pushing 2 to the top s.push(3); // Pushing 3 to the top s.push(4); // Pushing 4 to the top s.push(5); // Pushing 5 to the top // Printing in reverse order while (!s.isEmpty()) { System.out.print(s.pop() + " "); } // The output will be "5 4 3 2 1" } } # Python Code: stack = [] stack.append(1) # This pushes 1 to the stack top stack.append(2) # This pushes 2 to the stack top stack.append(3) # This pushes 3 to the stack top stack.append(4) # This pushes 4 to the stack top stack.append(5) # This pushes 5 to the stack top # printing the stack while stack: print(stack[-1], end=" ") stack.pop() # The above loop prints "5 4 3 2 1" # This code is contributed by Sakshi
using System; using System.Collections.Generic; class Program { static void Main() { Stack<int> s = new Stack<int>(); // Creating a stack // of integers s.Push(1); // Pushing 1 to the stack top s.Push(2); // Pushing 2 to the stack top s.Push(3); // Pushing 3 to the stack top s.Push(4); // Pushing 4 to the stack top s.Push(5); // Pushing 5 to the stack top // Printing the stack while (s.Count > 0) { Console.Write( s.Peek() + " "); // Peek() gets the top element // without removing it s.Pop(); // Pop() removes the top element } // The above loop prints "5 4 3 2 1" } } class Stack { constructor() { this.stack = []; } push(value) { this.stack.push(value); // Pushes the value to the stack top } top() { return this.stack[this.stack.length - 1]; // Returns the element at the top of the stack } pop() { return this.stack.pop(); // Removes and returns the top element of the stack } isEmpty() { return this.stack.length === 0; // Checks if the stack is empty } } function main() { const s = new Stack(); // Creating a stack s.push(1); // Pushing 1 to the stack top s.push(2); // Pushing 2 to the stack top s.push(3); // Pushing 3 to the stack top s.push(4); // Pushing 4 to the stack top s.push(5); // Pushing 5 to the stack top // Printing the stack while (!s.isEmpty()) { console.log(s.top() + " "); // Outputting the top element s.pop(); // Removing the top element } // The above loop prints "5 4 3 2 1" } main(); // Calling the main function Pop Operation in Stack:
Pop operation is used to remove an item from the stack.
The items are popped in the reversed order in which they are pushed. If the stack is empty, then it is said to be an Underflow condition.
Below is a sample program to show Pop operation in Stack.
C++ #include <bits/stdc++.h> using namespace std; int main() { stack<int> s; // creating a stack of integers s.push(1); // This pushes 1 to the stack top s.push(2); // This pushes 2 to the stack top s.push(3); // This pushes 3 to the stack top s.push(4); // This pushes 4 to the stack top s.push(5); // This pushes 5 to the stack top // Now, let us remove elements from the stack using pop function while (!s.empty()) { cout << s.top() << " "; s.pop(); // removes the top element from the stack } } import java.util.ArrayDeque; public class Main { public static void main(String[] args) { ArrayDeque<Integer> s = new ArrayDeque<>(); / s.push(1); // Pushing 1 to the stack top s.push(2); s.push(3); s.push(4); s.push(5); // Removing elements from the stack using pop function while (!s.isEmpty()) { System.out.print(s.peek() + " "); / s.pop(); } } } stack = [] stack.append(1) # This pushes 1 to the stack top stack.append(2) # This pushes 2 to the stack top stack.append(3) # This pushes 3 to the stack top stack.append(4) # This pushes 4 to the stack top stack.append(5) # This pushes 5 to the stack top # Now, let us remove elements from the stack using pop function while stack: print(stack[-1], end=" ") stack.pop() # removes the top element from the stack
using System; using System.Collections.Generic; class Program { static void Main() { // Creating a stack of integers Stack<int> s = new Stack<int>(); // Pushing elements onto the stack s.Push(1); // This pushes 1 to the stack top s.Push(2); // This pushes 2 to the stack top s.Push(3); // This pushes 3 to the stack top s.Push(4); // This pushes 4 to the stack top s.Push(5); // This pushes 5 to the stack top // Removing elements from the stack using Pop function while (s.Count > 0) { Console.Write(s.Peek() + " "); // Displaying the top element without removing it s.Pop(); // Removes the top element from the stack } } } // Creating a stack let stack = []; // Pushing elements to the stack stack.push(1); // This pushes 1 to the stack top stack.push(2); // This pushes 2 to the stack top stack.push(3); // This pushes 3 to the stack top stack.push(4); // This pushes 4 to the stack top stack.push(5); // This pushes 5 to the stack top // Removing elements from the stack using pop function while (stack.length > 0) { console.log(stack[stack.length - 1]); // Print the top element stack.pop(); // Removes the top element from the stack } Top Operation in Stack:
Top operation is used to return the top element of the stack.
Below is a sample program to show Pop operation in Stack.
C++ #include <bits/stdc++.h> using namespace std; int topElement(stack<int>& s) { return s.top(); } int main() { stack<int> s; // creating a stack of integers s.push(1); // This pushes 1 to the stack top cout << topElement(s) << endl; // Prints 1 since 1 is present at the // stack top s.push(2); // This pushes 2 to the stack top cout << topElement(s) << endl; // Prints 2 since 2 is present at the // stack top s.push(3); // This pushes 3 to the stack top cout << topElement(s) << endl; // Prints 3 since 3 is present at the // stack top } import java.util.ArrayDeque; public class StackExample { public static void main(String[] args) { ArrayDeque<Integer> s = new ArrayDeque<>(); // Pushing 1 to the stack top s.push(1); System.out.println(s.peek()); // Prints 1 // Pushing 2 to the stack top s.push(2); System.out.println(s.peek()); // Prints 2 // Pushing 3 to the stack top s.push(3); System.out.println(s.peek()); // Prints 3 } } # Python code: def topElement(s): return s[-1] s = [] # creating a stack of integers s.append(1) # This pushes 1 to the stack top print(topElement(s)) # Prints 1 since 1 is present at the stack top s.append(2) # This pushes 2 to the stack top print(topElement(s)) # Prints 2 since 2 is present at the stack top s.append(3) # This pushes 3 to the stack top print(topElement(s)) # Prints 3 since 3 is present at the stack top # This code is contributed by Sakshi
using System; using System.Collections.Generic; class Program { static int TopElement(Stack<int> s) { return s.Peek(); } static void Main() { Stack<int> s = new Stack<int>(); // creating a stack of integers s.Push(1); // This pushes 1 to the stack top Console.WriteLine(TopElement(s)); // Prints 1 since 1 is present at the stack top s.Push(2); // This pushes 2 to the stack top Console.WriteLine(TopElement(s)); // Prints 2 since 2 is present at the stack top s.Push(3); // This pushes 3 to the stack top Console.WriteLine(TopElement(s)); // Prints 3 since 3 is present at the stack top } } function topElement(s) { return s[s.length - 1]; } // Main function function main() { let s = []; // Creating an array to act as a stack s.push(1); // Pushing 1 to the stack console.log(topElement(s)); // Prints 1 since 1 is at the top of the stack s.push(2); // Pushing 2 to the stack console.log(topElement(s)); // Prints 2 since 2 is at the top of the stack s.push(3); // Pushing 3 to the stack console.log(topElement(s)); // Prints 3 since 3 is at the top of the stack } // Calling the main function main(); //THis code is contributed by Utkarsh isEmpty Operation in Stack:
isEmpty operation is a boolean operation that is used to determine if the stack is empty or not.
This operation will return true if the stack is empty, else false.
Below is a sample program to show Pop operation in Stack.
C++ #include <bits/stdc++.h> using namespace std; bool isEmpty(stack<int>& s) { bool isStackEmpty = s.empty(); // checking whether stack is empty or // not and storing it into isStackEmpty // variable return isStackEmpty; // returning bool value stored in // isStackEmpty } int main() { stack<int> s; // The if - else conditional statements below prints // "Stack is empty." if (isEmpty(s)) { cout << "Stack is empty." << endl; } else { cout << "Stack is not empty." << endl; } s.push(1); // Inserting value 1 to the stack top // The if - else conditional statements below prints // "Stack is not empty." if (isEmpty(s)) { cout << "Stack is empty." << endl; } else { cout << "Stack is not empty." << endl; } } import java.util.Stack; public class Main { public static boolean isEmpty(Stack<Integer> s) { return s.empty(); } public static void main(String[] args) { Stack<Integer> s = new Stack<>(); if (isEmpty(s)) { System.out.println("Stack is empty."); } else { System.out.println("Stack is not empty."); } s.push(1); if (isEmpty(s)) { System.out.println("Stack is empty."); } else { System.out.println("Stack is not empty."); } } } # Python Code: def isEmpty(s): isStackEmpty = len(s) == 0 # checking whether stack is empty or # not and storing it into isStackEmpty variable return isStackEmpty # returning bool value stored in isStackEmpty s = [] # The if - else conditional statements below prints "Stack is empty." if isEmpty(s): print("Stack is empty.") else: print("Stack is not empty.") s.append(1) # Inserting value 1 to the stack top # The if - else conditional statements below prints "Stack is not empty." if isEmpty(s): print("Stack is empty.") else: print("Stack is not empty.") # This code is contributed by Sakshi using System; using System.Collections.Generic; class Program { // Function to check if a stack is empty static bool IsEmpty(Stack<int> s) { return s.Count == 0; } static void Main() { Stack<int> s = new Stack<int>(); // Check if the stack is empty if (IsEmpty(s)) { Console.WriteLine("Stack is empty."); } else { Console.WriteLine("Stack is not empty."); } // Push a value (1) onto the stack s.Push(1); // Check if the stack is empty after pushing a value if (IsEmpty(s)) { Console.WriteLine("Stack is empty."); } else { Console.WriteLine("Stack is not empty."); } } } function isEmpty(stack) { // checking whether stack is empty or not return stack.length === 0; } function main() { const s = []; // The if - else conditional statements below prints "Stack is empty." if (isEmpty(s)) { console.log("Stack is empty."); } else { console.log("Stack is not empty."); } s.push(1); // Inserting value 1 to the stack top // The if - else conditional statements below prints "Stack is not empty." if (isEmpty(s)) { console.log("Stack is empty."); } else { console.log("Stack is not empty."); } } // Run the main function main(); //This code is contributed by Monu. OutputStack is empty. Stack is not empty.
size() Operation in Stack:
Size operation in Stack is used to return the count of elements that are present inside the stack.
Below is a sample program to show Pop operation in Stack.
C++ #include <bits/stdc++.h> using namespace std; int main() { stack<int> s; // creating a stack of integers cout << s.size() << endl; // Prints 0 since the stack is empty s.push(1); // This pushes 1 to the stack top s.push(2); // This pushes 2 to the stack top cout << s.size() << endl; // Prints 2 since the stack // contains two elements s.push(3); // This pushes 3 to the stack top cout << s.size() << endl; // Prints 3 since the stack // contains three elements } import java.util.ArrayDeque; public class Main { public static void main(String[] args) { ArrayDeque<Integer> s = new ArrayDeque<>(); System.out.println(s.size()); // Prints 0 since the stack is empty s.push(1); // Pushing 1 to the stack top s.push(2); // Pushing 2 to the stack top System.out.println(s.size()); // Prints 2 since the stack contains two elements s.push(3); // Pushing 3 to the stack top System.out.println(s.size()); // Prints 3 since the stack contains three elements } } # PYthon Code: stack = [] # creating an empty list as a stack print(len(stack)) # Prints 0 since the stack is empty stack.append(1) # This appends 1 to the stack stack.append(2) # This appends 2 to the stack print(len(stack)) # Prints 2 since the stack contains two elements stack.append(3) # This appends 3 to the stack print(len(stack)) # Prints 3 since the stack contains three element # This code is contributed by Sakshi
using System; using System.Collections.Generic; public class Program { public static void Main(string[] args) { Stack<int> s = new Stack<int>(); // creating a stack of integers Console.WriteLine(s.Count); // Prints 0 since the stack is empty s.Push(1); // This pushes 1 to the stack top s.Push(2); // This pushes 2 to the stack top Console.WriteLine(s.Count); // Prints 2 since the stack contains two elements s.Push(3); // This pushes 3 to the stack top Console.WriteLine(s.Count); // Prints 3 since the stack contains three elements } } //This code is contribiuted by Kishan. let stack = []; // Creating an array to simulate a stack console.log(stack.length); // Prints 0 since the stack is empty stack.push(1); // This pushes 1 to the stack top stack.push(2); // This pushes 2 to the stack top console.log(stack.length); // Prints 2 since the stack contains two elements stack.push(3); // This pushes 3 to the stack top console.log(stack.length); // Prints 3 since the stack contains three elements //This code is contributed by Aman.
Similar Reads
Basic Operations on Binary Tree with Implementations
The tree is a hierarchical Data Structure. A binary tree is a tree that has at most two children. The node which is on the left of the Binary Tree is called “Left-Child†and the node which is on the right is called “Right-Childâ€. Also, the smaller tree or the subtree in the left of the root node is
11 min read
Basic Operations for Queue in Data Structure
Queue is a linear data structure that follows FIFO (First In First Out) Principle, so the first element inserted is the first to be popped out. Basic Operations on Queue Some of the basic operations for Queue in Data Structure are: enqueue() - Insertion of elements to the queue.dequeue() - Removal o
5 min read
Java Program to Implement Stack Data Structure
Stack is the fundamental Data Structure that can follow the Last In, First Out(LIFO) principle. It can work that the last element added to the stack will be the first one to be removed. It can operate like a stack of plates: We can only add or remove the topmost plate at any given time. The simplici
5 min read
Design and Implement Special Stack Data Structure
Design a Data Structure SpecialStack that supports all the stack operations like push(), pop(), isEmpty(), isFull() and an additional operation getMin() which should return minimum element from the SpecialStack. All these operations of SpecialStack must be O(1). To implement SpecialStack, you should
1 min read
Commonly Asked Data Structure Interview Questions on Stack
Stacks are a fundamental data structure used in many real-world applications, including expression evaluation, function call management, and backtracking algorithms. A stack follows the Last In, First Out (LIFO) principle, meaning the last element added is the first to be removed. Understanding stac
5 min read
Design a stack with operations on middle element
Design a stack data structure that supports the following four operations, each in constant time complexity, i.e., O(1): push(x): Insert an element x onto the top of the stack.pop(): Remove and return the element at the top of the stack.findMiddle(): Retrieve the middle element of the stack without
12 min read
C# Program to Implement an Interface in a Structure
Structure is a value type and a collection of variables of different data types under a single unit. It is almost similar to a class because both are user-defined data types and both hold a bunch of different data types. We can create a structure by using struct keyword. A structure can also hold co
2 min read
Implement Dynamic Multi Stack (K stacks) using only one Data Structure
In this article, we will see how to create a data structure that can handle multiple stacks with growable size. The data structure needs to handle three operations: push(x, stackNum) = pushes value x to the stack numbered stackNumpop(stackNum) = pop the top element from the stack numbered stackNumto
15+ min read
Introduction to Built-in Data Structures in C#
In the C#, we have data structures like a dictionary, array, stack, hashtable, queue, Linkedlist, etc. Each data structure allows us to play with the collection of data with different principles. Let’s see what inbuilt Data Structures C# offers us: In-Built Data Structure Internal Implementation Sta
3 min read
Common operations on various Data Structures
Data Structure is the way of storing data in computer's memory so that it can be used easily and efficiently. There are different data-structures used for the storage of data. It can also be defined as a mathematical or logical model of a particular organization of data items. The representation of
15+ min read