Basic Operations in Stack Data Structure

Last Updated : 22 Sep, 2025

Stack is a linear data structure that follows the LIFO (Last In First Out) principle for inserting and deleting elements from it.

In order to work with a stack, we have some fundamental operations that allow us to insert, remove, and access elements efficiently. These include:

push() to insert an element into the stack
top() Returns the top element of the stack.
pop() to remove an element from the stack
isEmpty() returns true if the stack is empty else false.
size() returns the size of the stack.

We will now see how to perform these operations on Stack.

Push Operation in Stack:

Push operation is used to insert an element onto the top of the stack.

Push-Operation-in-Stack-(1)

C++

#include <stack>
using namespace std; 

int main() {

    // creating a stack of integers
    stack<int> st;  

    // This pushes 1 to the stack top
    st.push(1); 
    
    // This pushes 2 to the stack top
    st.push(2); 
    
    // This pushes 3 to the stack top
    st.push(3);  
}

Java

import java.util.Stack;

class GfG {
    public static void main(String[] args) {
        
        // creating a stack of integers
        Stack<Integer> st = new Stack<>();

        // pushing elements into the stack
        
        // pushes 1
        st.push(1);  
        
        // pushes 2
        st.push(2);  
        
        // pushes 3
        st.push(3);  
    }
}

Python

if __name__ == "__main__":
    # creating a stack of integers
    st = []
    
    # pushing elements into the stack
    
    # pushes 1
    st.append(1) 
    
    # pushes 2
    st.append(2)
    
    # pushes 3
    st.append(3)

C#

using System;
using System.Collections.Generic;

class GfG {
    static void Main() {
        
        // creating a stack of integers
        Stack<int> st = new Stack<int>();

        // pushing elements into the stack
        st.Push(1);  // pushes 1
        st.Push(2);  // pushes 2
        st.Push(3);  // pushes 3
    }
}

JavaScript

// Driver Code
// creating a stack using array
let st = [];

// pushing elements into the stack
st.push(1);  // pushes 1
st.push(2);  // pushes 2
st.push(3);  // pushes 3

Time Complexity: O(1), since insertion at the top takes constant time.
Auxiliary Space: O(1)

Note: If the stack is implemented using a fixed-size array, inserting an element into a full stack will cause an overflow condition.

Top or Peek Operation in Stack:

Top or Peek operation is used to get the top element of the stack.

Top-or-Peek-Operation-in-Stack-(1)

C++

#include <iostream>
#include <stack>
using namespace std;

int main() {
    
    // creating a stack of integers
    stack<int> st; 
    
    st.push(1); 
    st.push(2); 
    st.push(3); 
        
    // Printing Current top element 
    cout << st.top() << " ";
    
    return 0;
}

Java

import java.util.Stack;

class GfG {
    public static void main(String[] args) {
        
        // creating a stack of integers
        Stack<Integer> st = new Stack<>();
        
        st.push(1);
        st.push(2);
        st.push(3);
    
        // Printing current top element
        System.out.print(st.peek() + " ");
    }
}

Python

if __name__ == "__main__":
    
    # creating a stack of integers
    st = []

    st.append(1)
    st.append(2)
    st.append(3)

    # Printing current top element
    print(st[-1])

C#

using System;
using System.Collections.Generic;

class GfG {
    static void Main() {
    
        // creating a stack of integers
        Stack<int> st = new Stack<int>();
        
        st.Push(1);
        st.Push(2);
        st.Push(3);
        
        // Printing current top element
        Console.Write(st.Peek() + " ");
    }
}

JavaScript

// Driver Code

// creating a stack using array
let st = [];

st.push(1);
st.push(2);
st.push(3);

// Printing current top element
console.log(st[st.length - 1].toString() + " ");

Output

Time Complexity: O(1)
Auxiliary Space: O(1)

Pop Operation in Stack:

Pop operation is used to remove an element from the top of the stack.

The items are popped in the reversed order in which they are pushed.

Pop-Operation-in-Stack-(1)

C++

#include <iostream>
#include <stack>
using namespace std;

int main() {
    
    // creating a stack of integers
    stack<int> st; 
    
    st.push(1); 
    st.push(2); 
    st.push(3); 

    // Printing Current top element 
    cout << st.top() << " ";
        
    // removes the top element from the stack
    st.pop(); 
    
    // Printing Current top element 
    cout << st.top() << " ";
        
    // removes the top element from the stack
    st.pop(); 
}

Java

import java.util.Stack;

class GfG {
    public static void main(String[] args) {
        
        // creating a stack of integers
        Stack<Integer> st = new Stack<>();
        
        st.push(1);
        st.push(2);
        st.push(3);

        // Printing current top element
        System.out.print(st.peek() + " ");
            
        // removes the top element from the stack
        st.pop();
        
        // Printing current top element
        System.out.print(st.peek() + " ");
            
        // removes the top element from the stack
        st.pop();
    }
}

Python

if __name__ == "__main__":
   
    # creating a stack of integers
    st = []

    st.append(1)
    st.append(2)
    st.append(3)

    # Printing current top element
    print(st[-1], end=" ")

    # removes the top element from the stack
    st.pop()

    # Printing current top element
    print(st[-1], end=" ")

    # removes the top element from the stack
    st.pop()

C#

using System;
using System.Collections.Generic;

class GfG {
    static void Main() {
        
        // creating a stack of integers
        Stack<int> st = new Stack<int>();
        
        st.Push(1);
        st.Push(2);
        st.Push(3);
        
        // Printing current top element
        Console.Write(st.Peek() + " ");
            
        // removes the top element from the stack
        st.Pop();
                
        // Printing current top element
        Console.Write(st.Peek() + " ");
            
        // removes the top element from the stack
        st.Pop();
    }
}

JavaScript

// Driver Code

// creating a stack using array
let st = [];

st.push(1);
st.push(2);
st.push(3);

// Printing current top element
process.stdout.write(st[st.length - 1] + ' ');
    
// removes the top element from the stack
st.pop();

// Printing current top element
process.stdout.write(st[st.length - 1] + ' ');
    
// removes the top element from the stack
st.pop();

Output

3 2 1

Time Complexity: O(1)
Auxiliary Space: O(1)

Note: If a stack is empty, deleting an element will cause an underflow condition.

isEmpty Operation in Stack:

isEmpty operation is a boolean operation that is used to determine if the stack is empty or not. This will return true if the stack is empty, else false.

isEmpty-Operation-in-Stack-(1)

C++

#include <iostream>
#include <stack>
using namespace std;

int main() { 

    stack<int> st; 

    // if stack is empty returns true else false
    if (st.empty()) { 
        cout << "Stack is empty." << endl; 
    } 
    else { 
        cout << "Stack is not empty." << endl; 
    } 

    // Inserting value 1 to the stack top 
    st.push(1);

    // if stack is empty returns true else false
    if (st.empty()) { 
        cout << "Stack is empty." << endl; 
    } 
    else { 
        cout << "Stack is not empty." << endl; 
    } 
}

Java

import java.util.Stack;

public class GfG {
    public static void main(String[] args) {
        Stack<Integer> st = new Stack<>();

        // if stack is empty returns true else false
        if (st.isEmpty()) {
            System.out.println("Stack is empty.");
        } else {
            System.out.println("Stack is not empty.");
        }

        // Inserting value 1 to the stack top
        st.push(1);

        // if stack is empty returns true else false
        if (st.isEmpty()) {
            System.out.println("Stack is empty.");
        } else {
            System.out.println("Stack is not empty.");
        }
    }
}

Python

if __name__ == "__main__":
    st = []

    # if stack is empty returns true else false
    if len(st) == 0:
        print("Stack is empty.")
    else:
        print("Stack is not empty.")

    # Inserting value 1 to the stack top
    st.append(1)

    # if stack is empty returns true else false
    if len(st) == 0:
        print("Stack is empty.")
    else:
        print("Stack is not empty.")

C#

using System;
using System.Collections.Generic;

class GfG {
    static void Main() {
        
        Stack<int> st = new Stack<int>();
        
        // if stack is empty returns true else false
        if (st.Count == 0) {
            Console.WriteLine("Stack is empty.");
        } else {
            Console.WriteLine("Stack is not empty.");
        }
        
        // Inserting value 1 to the stack top
        st.Push(1);
        
        // if stack is empty returns true else false
        if (st.Count == 0) {
            Console.WriteLine("Stack is empty.");
        } else {
            Console.WriteLine("Stack is not empty.");
        }
    }
}

JavaScript

// Driver Code
let st = [];

// if stack is empty returns true else false
if (st.length === 0) {
    console.log("Stack is empty.");
} else {
    console.log("Stack is not empty.");
}

// Inserting value 1 to the stack top
st.push(1);

// if stack is empty returns true else false
if (st.length === 0) {
    console.log("Stack is empty.");
} else {
    console.log("Stack is not empty.");
}

Output

Stack is empty.
Stack is not empty.

Time Complexity: O(1)
Auxiliary Space: O(1)

Size Operation in Stack:

Size operation in Stack is used to return the count of elements that are present inside the stack.

C++

#include <iostream>
#include <stack>
using namespace std; 

int main() { 

    stack<int> st; 

    // Checking Current stack size
    cout << st.size() << endl;

    st.push(1);
    st.push(2); 

    // Checking current stack size 
    cout << st.size() << endl; 
}

Java

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Stack<Integer> st = new Stack<>();
        
        // Checking Current stack size
        System.out.println(st.size()); 
        
        st.push(1); 
        st.push(2); 
        
        // Checking Current stack size
        System.out.println(st.size());
    }
}

Python

if __name__ == "__main__":
    st = []

    # Checking current stack size
    print(len(st))

    st.append(1)
    st.append(2)

    # Checking current stack size
    print(len(st))

C#

using System;
using System.Collections.Generic;

class GfG {
    static void Main() {
        Stack<int> st = new Stack<int>();

        // Checking current stack size
        Console.WriteLine(st.Count);

        st.Push(1);
        st.Push(2);

        // Checking current stack size
        Console.WriteLine(st.Count);
    }
}

JavaScript

// Driver Code
let st = [];

// Checking current stack size
console.log(st.length);

st.push(1);
st.push(2);

// Checking current stack size
console.log(st.length);

Output

0
2

Time Complexity: O(1)
Auxiliary Space: O(1)

Applications of Stack

Applications of Stack

Stack Data Structure

C

Improve

Article Tags :

Stack
DSA

Explore