Skip to content
geeksforgeeks
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • Tutorials
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
  • Practice
    • Build your AI Agent
    • GfG 160
    • Problem of the Day
    • Practice Coding Problems
    • GfG SDE Sheet
  • Contests
    • Accenture Hackathon (Ending Soon!)
    • GfG Weekly [Rated Contest]
    • Job-A-Thon Hiring Challenge
    • All Contests and Events
  • Java Arrays
  • Java Strings
  • Java OOPs
  • Java Collection
  • Java 8 Tutorial
  • Java Multithreading
  • Java Exception Handling
  • Java Programs
  • Java Project
  • Java Collections Interview
  • Java Interview Questions
  • Java MCQs
  • Spring
  • Spring MVC
  • Spring Boot
  • Hibernate
Open In App
Next Article:
Stack in Python
Next article icon

Stack Class in Java

Last Updated : 15 Apr, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

The Java Collection framework provides a Stack class, which implements a Stack data structure. The class is based on the basic principle of LIFO (last-in-first-out). Besides the basic push and pop operations, the class also provides three more functions, such as empty, search, and peek.

  • The Stack class extends Vector and provides additional functionality for stack operations, such as push, pop, peek, empty, and search.
  • The Stack class can be considered as a subclass of Vector because it inherits all of its methods and properties.

Example: Here, we are implementing the Stack class.

Java 
// Java Program Implementing Stack Class import java.util.Stack;  public class Geeks  {     public static void main(String[] args)      {         // Create a new stack         Stack<Integer> s = new Stack<>();          // Push elements onto the stack         s.push(1);         s.push(2);         s.push(3);         s.push(4);          // Pop elements from the stack         while(!s.isEmpty()) {             System.out.println(s.pop());         }     } }

Output
4 3 2 1

Explanation: In the above example, we are creating an empty stack of integer and then we are pushing four elements onto the stack with the help of push() method. After that we enter a loop where we keep on popping the elements with the help of pop() method and printing the elements until the stack is empty.

Note: The elements are popped in reverse order because we know the stack follows LIFO principle.

Hierarchy of Stack class

The below diagram shows the hierarchy of the Stack class: 

Stack Class in Java


The class supports one default constructor Stack() which is used to create an empty stack. 

Declaration of Stack

public class Stack<E> extends Vector<E>

All Implemented Interfaces:

  • Serializable: This interface allows a class to be serialized and deserialized
  • Cloneable: This interface creates copies of objects from the class.
  • Iterable<E>: This interface helps to iterate on a collection of objects one by one.
  • Collection<E>: This interface is used to represent a group of objects which is known as elements. It is used to work with collections of objects.
  • List<E>: This interface is used for sorting items in a specific order.
  • RandomAccess: This is a marker interface which indicates that the list allow quick access to elements in constant time.

How to Create a Stack?

In order to create a stack, we must import java.util.stack package and use the Stack() constructor of this class. The below example creates an empty Stack.

Stack<E> stack = new Stack<E>();

Here, E is the type of Object.

Example: Here, we are performing various operations in stack.

Java 
// Java code for stack implementation import java.util.Stack;  class Geeks {        // Pushing element on the top of the stack     static void stack_push(Stack<Integer> stack)     {         for(int i = 0; i < 5; i++)         {             stack.push(i);         }     }          // Popping element from the top of the stack     static void stack_pop(Stack<Integer> stack)     {         System.out.println("Pop Operation:");          for(int i = 0; i < 5; i++)         {             Integer y = (Integer) stack.pop();             System.out.println(y);         }     }      // Displaying element on the top of the stack     static void stack_peek(Stack<Integer> stack)     {         Integer element = (Integer) stack.peek();         System.out.println("Element on stack top: " + element);     }          // Searching element in the stack     static void stack_search(Stack<Integer> stack, int element)     {         Integer pos = (Integer) stack.search(element);          if(pos == -1)             System.out.println("Element not found");         else             System.out.println("Element is found at position: " + pos);     }       public static void main (String[] args)     {         Stack<Integer> stack = new Stack<Integer>();          stack_push(stack);         stack_pop(stack);         stack_push(stack);         stack_peek(stack);         stack_search(stack, 2);         stack_search(stack, 6);     } }

Output
Pop Operation: 4 3 2 1 0 Element on stack top: 4 Element is found at position: 3 Element not found


Performing Different Operations on Stack Class

1. Adding Elements: With the help of push() method we can add element to the stack. The push() method place the element at the top of the stack.

Example: Here we are creating a stack with both default and generic types and pushing element onto the stack.

Java 
// Java program to add the // elements in the stack import java.io.*; import java.util.*;  class Geeks {        // Main Method     public static void main(String[] args)     {          // Default initialization of Stack         Stack stack1 = new Stack();          // Initialization of Stack         // using Generics         Stack<String> stack2 = new Stack<String>();          // pushing the elements         stack1.push("4");         stack1.push("All");         stack1.push("Geeks");          stack2.push("Geeks");         stack2.push("For");         stack2.push("Geeks");            // Printing the Stack Elements         System.out.println(stack1);         System.out.println(stack2);     } }

Output
[4, All, Geeks] [Geeks, For, Geeks]


2. Accessing the Element: With the help of peek() method we can fetch the top element of the stack. 

Example: Here, we are using peek() to access the top element of the stack.

Java 
// Java program to demonstrate the accessing // of the elements from the stack import java.util.*; import java.io.*;  public class Geeks {      // Main Method     public static void main(String args[])     {         // Creating an empty Stack         Stack<String> stack = new Stack<String>();          // Use push() to add elements into the Stack         stack.push("Welcome");         stack.push("To");         stack.push("Geeks");         stack.push("For");         stack.push("Geeks");          // Displaying the Stack         System.out.println("Initial Stack: " + stack);          // Fetching the element at the head of the Stack         System.out.println("The element at the top of the"                            + " stack is: " + stack.peek());          // Displaying the Stack after the Operation         System.out.println("Final Stack: " + stack);     } }

Output
Initial Stack: [Welcome, To, Geeks, For, Geeks] The element at the top of the stack is: Geeks Final Stack: [Welcome, To, Geeks, For, Geeks]


3. Removing Elements: With the help of pop() method we can delete and return the top element from the stack.

Example: Here, we are removing element from the stack using pop().

Java 
// Java program to demonstrate the removing // of the elements from the stack import java.util.*; import java.io.*;  public class Geeks {     public static void main(String args[])     {         // Creating an empty Stack         Stack<Integer> stack = new Stack<Integer>();          // Use add() method to add elements         stack.push(10);         stack.push(15);         stack.push(30);         stack.push(20);         stack.push(5);          // Displaying the Stack         System.out.println("Initial Stack: " + stack);          // Removing elements using pop() method         System.out.println("Popped element: "                            + stack.pop());         System.out.println("Popped element: "                            + stack.pop());          // Displaying the Stack after pop operation         System.out.println("Stack after pop operation "                            + stack);               System.out.println("Is stack empty? " + stack.empty());         // Pop remaining elements         stack.pop();         stack.pop();         stack.pop();          // Check if the stack is empty         System.out.println("Is stack empty? " + stack.empty());     } }

Output
Initial Stack: [10, 15, 30, 20, 5] Popped element: 5 Popped element: 20 Stack after pop operation [10, 15, 30] Is stack empty? false Is stack empty? true

The Stack class offers many methods for working with stack, such as peek(), this method is used to retrieve the top element without removing it, search(), this method search for an element in the stack and return its position, and size(), this method return the current size of the stack.

The Stack class in Java provides only a default constructor, which creates an empty stack. If you want to create a stack with a specified initial capacity, you would need to extend the Vector class (which Stack itself extends) and set the initial capacity in the constructor of your custom class.

Methods in Stack Class 

Method

Description

empty()

This method returns true if nothing is on the top of the stack. Else, returns false.

peek()

This method returns the element on the top of the stack, but does not remove it.

pop()

This method removes and returns the top element of the stack.

An exception is thrown if we call pop() when the invoking stack is empty.

push(Object element)

This method pushes an element on the top of the stack.

search(Object element)

This method is used to determine whether an object exists in the stack. If the element is found,

It returns the position of the element from the top of the stack. Else, it returns -1.


Methods Inherited from Class java.util.Vector

Method

Description

add(Object obj)This method is used to appends the specified element to the end of the Vector.
add(int index, Object obj)This method is used to inserts the specified element at the specified position in the Vector.
addAll(Collection c)

This method is used to appends all of the elements in the specified Collection to the end of theVector, 

in the order that they are returned by the specified Collection’s Iterator.

addAll(int index, Collection c)This method is used to inserts all the elements in the specified Collection into this Vector at the specified position.
addElement(Object o)This method is used to adds the specified component to the end of the vector
capacity()This method returns the current capacity of the vector.
clear()This method removes all the elements from the Vector.
clone()This method returns a clone of the vector.
contains(Object o)This method returns true if this vector contains the specified element.
containsAll(Collection c)This method returns true if this Vector contains all the elements in the specified Collection.
copyInto(Object []array)This method is used to copies the components of this vector into the specified array.
elementAt(int index)This method returns the component at the specified index.
elements()This method returns an enumeration of the components of the vector.
ensureCapacity(int minCapacity)

This method increases the capacity of the vector, if necessary, to ensure that it can hold 

at least the number of components specified by the minimum capacity argument.

equals()This method compares the specified Object with the Vector for equality.
firstElement()This method returns the first component (the item at index 0) of the vector.
get(int index)This method returns the element at the specified position in the Vector.
hashCode()This method returns the hash code value for the Vector.
indexOf(Object o)

This method returns the index of the first occurrence of the specified element in this vector, or -1 

if this vector does not contain the element.

indexOf(Object o, int index)This method returns the index of the first occurrence of the specified element in this vector, searching forwards from the index, or returns -1 if the element is not found.
insertElementAt(Object o, int index)This method inserts the specified object as a component in this vector at the specified index.
isEmpty()This method tests if this vector has no components.
iterator()This method returns an iterator over the elements in this list in proper sequence.
lastElement()This method returns the last component of the vector.
lastIndexOf(Object o)

This method returns the index of the last occurrence of the specified element in this vector, or -1

 If this vector does not contain the element.

lastIndexOf(Object o, int index)

This method returns the index of the last occurrence of the specified element in this vector, 

searching backward from the index, or returns -1 if the element is not found.

listIterator()This method returns a list iterator over the elements in this list (in proper sequence).
listIterator(int index)

This method returns a list iterator over the elements in this list (in proper sequence), 

starting at the specified position in the list.

remove(int index)This method removes the element at the specified position in this Vector.
remove(Object o)This method removes the first occurrence of the specified element in this Vector If the Vector does not contain the element, it is unchanged.
removeAll(Collection c)This method removes from this Vector all of its elements that are contained in the specified Collection.
removeAllElements()This method removes all components from this vector and sets its size to zero.
removeElement(Object o)This method removes the first (lowest-indexed) occurrence of the argument from this vector.
removeElementAt(int index)This method deletes the component at the specified index.
removeRange(int fromIndex, int toIndex)This method removes from this list all the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
retainAll(Collection c)This method retains only the elements in this Vector that are contained in the specified Collection.
set(int index, Object o)This method replaces the element at the specified position in this Vector with the specified element.
setElementAt(Object o, int index)This method sets the component at the specified index of this vector to be the specified object.
setSize(int newSize)This method sets the size of this vector.
size()This method returns the number of components in this vector.
subList(int fromIndex, int toIndex)This method returns a view of the portion of this List between fromIndex, inclusive, and toIndex, exclusive.
toArray()This method returns an array containing all of the elements in this Vector in the correct order.
toArray(Object []array)

This method returns an array containing all of the elements in this Vector in the correct order; the runtime

 type of the returned array is that of the specified array.

toString()This method returns a string representation of this Vector, containing the String representation of each element.
trimToSize()This method trims the capacity of this vector to be the vector’s current size.


Prioritize Use of Deque over Stack

The Stack class in Java is inherits from Vector in Java. It is a thread-safe class. It is recommended to use ArrayDeque for stack implementation as it is more efficient in a single-threaded environment.

Example: Here, we are implementing stack with the help of ArrayDeque.

Java 
// A Java Program to show implementation // of Stack using ArrayDeque import java.util.*;  class Geeks {     public static void main (String[] args) {         Deque<Character> stack = new ArrayDeque<Character>();         stack.push('A');         stack.push('B');         System.out.println(stack.peek());         System.out.println(stack.pop());     } }

Output
B B


One more reason to use Deque over Stack is Deque has the ability to use streams convert to list with keeping LIFO concept applied while Stack does not.

Example: Here, we are converting stack and deque into a lists and printing their elements in java using streams.

Java 
import java.util.*; import java.util.stream.Collectors;  class Geeks {     public static void main (String[] args) {             Stack<Integer> stack = new Stack<>();         Deque<Integer> deque = new ArrayDeque<>();          stack.push(1);         deque.push(1);         stack.push(2);         deque.push(2);          List<Integer> list1 = stack.stream().collect(Collectors.toList());           System.out.println("Using Stack: ");           for(int i = 0; i < list1.size(); i++){               System.out.print(list1.get(i) + " " );         }           System.out.println();          List<Integer> list2 = deque.stream().collect(Collectors.toList());           System.out.println("Using Deque: ");           for(int i = 0; i < list2.size(); i++){               System.out.print(list2.get(i) + " " );         }           System.out.println();            } }

Output
Using Stack:  1 2  Using Deque:  2 1


Next Article
Stack in Python
author
kartik
Improve
Article Tags :
  • Java
  • Java - util package
  • Java-Collections
  • Java-Stack
Practice Tags :
  • Java
  • Java-Collections

Similar Reads

  • Stack Data Structure
    A Stack is a linear data structure that follows a particular order in which the operations are performed. The order may be LIFO(Last In First Out) or FILO(First In Last Out). LIFO implies that the element that is inserted last, comes out first and FILO implies that the element that is inserted first
    3 min read
  • What is Stack Data Structure? A Complete Tutorial
    Stack is a linear data structure that follows LIFO (Last In First Out) Principle, the last element inserted is the first to be popped out. It means both insertion and deletion operations happen at one end only. LIFO(Last In First Out) PrincipleHere are some real world examples of LIFO Consider a sta
    4 min read
  • Applications, Advantages and Disadvantages of Stack
    A stack is a linear data structure in which the insertion of a new element and removal of an existing element takes place at the same end represented as the top of the stack. Applications of Stacks:Function calls: Stacks are used to keep track of the return addresses of function calls, allowing the
    2 min read
  • Implement a stack using singly linked list
    To implement a stack using a singly linked list, we need to ensure that all operations follow the LIFO (Last In, First Out) principle. This means that the most recently added element is always the first one to be removed. In this approach, we use a singly linked list, where each node contains data a
    13 min read
  • Introduction to Monotonic Stack - Data Structure and Algorithm Tutorials
    A monotonic stack is a special data structure used in algorithmic problem-solving. Monotonic Stack maintaining elements in either increasing or decreasing order. It is commonly used to efficiently solve problems such as finding the next greater or smaller element in an array etc. Table of Content Wh
    12 min read
  • Difference Between Stack and Queue Data Structures
    In computer science, data structures are fundamental concepts that are crucial for organizing and storing data efficiently. Among the various data structures, stacks and queues are two of the most basic yet essential structures used in programming and algorithm design. Despite their simplicity, they
    4 min read

    • Stack implementation in different language

    • Stack in C++ STL
      In C++, stack container follows LIFO (Last In First Out) order of insertion and deletion. It means that most recently inserted element is removed first and the first inserted element will be removed last. This is done by inserting and deleting elements at only one end of the stack which is generally
      5 min read
    • Stack Class in Java
      The Java Collection framework provides a Stack class, which implements a Stack data structure. The class is based on the basic principle of LIFO (last-in-first-out). Besides the basic push and pop operations, the class also provides three more functions, such as empty, search, and peek. The Stack cl
      12 min read
    • Stack in Python
      A stack is a linear data structure that stores items in a Last-In/First-Out (LIFO) or First-In/Last-Out (FILO) manner. In stack, a new element is added at one end and an element is removed from that end only. The insert and delete operations are often called push and pop. The functions associated wi
      8 min read
    • C# Stack with Examples
      In C# a Stack is a Collection that follows the Last-In-First-Out (LIFO) principle. It is used when we need last-in, first-out access to items. In C# there are both generic and non-generic types of Stacks. The generic stack is in the System.Collections.Generic namespace, while the non-generic stack i
      6 min read
    • Implementation of Stack in JavaScript
      A stack is a fundamental data structure in computer science that follows the Last In, First Out (LIFO) principle. This means that the last element added to the stack will be the first one to be removed. Stacks are widely used in various applications, such as function call management, undo mechanisms
      4 min read
    • Stack in Scala
      A stack is a data structure that follows the last-in, first-out(LIFO) principle. We can add or remove element only from one end called top. Scala has both mutable and immutable versions of a stack. Syntax : import scala.collection.mutable.Stack var s = Stack[type]() // OR var s = Stack(val1, val2, v
      3 min read

    Some questions related to Stack implementation

    • 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
    • Implement two Stacks in an Array
      Create a data structure twoStacks that represent two stacks. Implementation of twoStacks should use only one array, i.e., both stacks should use the same array for storing elements. Following functions must be supported by twoStacks. push1(int x) --> pushes x to first stack push2(int x) --> pu
      12 min read
    • Implement Stack using Queues
      Implement a stack using queues. The stack should support the following operations: Push(x): Push an element onto the stack.Pop(): Pop the element from the top of the stack and return it. A Stack can be implemented using two queues. Let Stack to be implemented be 's' and queues used to implement are
      15+ min read
    • Implement k stacks in an array
      Given an array of size n, the task is to implement k stacks using a single array. We mainly need to perform the following type of queries on the stack. push(x, i) : This operations pushes the element x into stack i pop(i) : This operation pops the top of stack i Here i varies from 0 to k-1 Naive App
      15+ min read
    • Design a stack that supports getMin() in O(1) time
      Design a Data Structure SpecialStack that supports all the stack operations like push(), pop(), peek() and an additional operation getMin() which should return minimum element from the SpecialStack. All these operations of SpecialStack must have a time complexity of O(1). Example: Input: queries = [
      15+ min read
    • Implement a stack using single queue
      We are given a queue data structure, the task is to implement a stack using a single queue. Also Read: Stack using two queues The idea is to keep the newly inserted element always at the front of the queue, preserving the order of previous elements by appending the new element at the back and rotati
      5 min read
    • How to implement stack using priority queue or heap?
      How to Implement stack using a priority queue(using min heap)? Asked In: Microsoft, Adobe.  Solution: In the priority queue, we assign priority to the elements that are being pushed. A stack requires elements to be processed in the Last in First Out manner. The idea is to associate a count that dete
      6 min read
    • Create a customized data structure which evaluates functions in O(1)
      Create a customized data structure such that it has functions :- GetLastElement(); RemoveLastElement(); AddElement() GetMin() All the functions should be of O(1) Question Source : amazon interview questions Approach : create a custom stack of type structure with two elements, (element, min_till_now)
      7 min read
    • Implement Stack and Queue using Deque
      Deque also known as double ended queue, as name suggests is a special kind of queue in which insertions and deletions can be done at the last as well as at the beginning. A link-list representation of deque is such that each node points to the next node as well as the previous node. So that insertio
      15 min read

    Easy problems on Stack

    • Infix to Postfix Expression
      Write a program to convert an Infix expression to Postfix form. Infix expression: The expression of the form "a operator b" (a + b) i.e., when an operator is in-between every pair of operands.Postfix expression: The expression of the form "a b operator" (ab+) i.e., When every pair of operands is fol
      9 min read
    • Prefix to Infix Conversion
      Infix : An expression is called the Infix expression if the operator appears in between the operands in the expression. Simply of the form (operand1 operator operand2). Example : (A+B) * (C-D) Prefix : An expression is called the prefix expression if the operator appears in the expression before the
      6 min read
    • Prefix to Postfix Conversion
      Given a Prefix expression, convert it into a Postfix expression. Conversion of Prefix expression directly to Postfix without going through the process of converting them first to Infix and then to Postfix is much better in terms of computation and better understanding the expression (Computers evalu
      6 min read
    • Postfix to Prefix Conversion
      Postfix: An expression is called the postfix expression if the operator appears in the expression after the operands. Simply of the form (operand1 operand2 operator). Example : AB+CD-* (Infix : (A+B) * (C-D) ) Prefix : An expression is called the prefix expression if the operator appears in the expr
      7 min read
    • Postfix to Infix
      Postfix to infix conversion involves transforming expressions where operators follow their operands (postfix notation) into standard mathematical expressions with operators placed between operands (infix notation). This conversion improves readability and understanding. Infix expression: The express
      5 min read
    • Convert Infix To Prefix Notation
      Given an infix expression consisting of operators (+, -, *, /, ^) and operands (lowercase characters), the task is to convert it to a prefix expression. Infix Expression: The expression of type a 'operator' b (a+b, where + is an operator) i.e., when the operator is between two operands. Prefix Expre
      8 min read
    • Valid Parentheses in an Expression
      Given a string s representing an expression containing various types of brackets: {}, (), and [], the task is to determine whether the brackets in the expression are balanced or not. A balanced expression is one where every opening bracket has a corresponding closing bracket in the correct order. Ex
      8 min read
    • Arithmetic Expression Evaluation
      The stack organization is very effective in evaluating arithmetic expressions. Expressions are usually represented in what is known as Infix notation, in which each operator is written between two operands (i.e., A + B). With this notation, we must distinguish between ( A + B )*C and A + ( B * C ) b
      2 min read
    • Evaluation of Postfix Expression
      Given a postfix expression, the task is to evaluate the postfix expression. A Postfix expression is of the form "a b operator" ("a b +") i.e., a pair of operands is followed by an operator. Examples: Input: arr = ["2", "3", "1", "*", "+", "9", "-"]Output: -4Explanation: If the expression is converte
      6 min read
    • How to Reverse a Stack using Recursion
      Write a program to reverse a stack using recursion, without using any loop. Example: Input: elements present in stack from top to bottom 4 3 2 1Output: 1 2 3 4 Input: elements present in stack from top to bottom 1 2 3Output: 3 2 1 The idea of the solution is to hold all values in Function Call Stack
      4 min read
    • Reverse individual words
      Given string str, we need to print the reverse of individual words. Examples: Input: Hello WorldOutput: olleH dlroWExplanation: Each word in "Hello World" is reversed individually, preserving the original order, resulting in "olleH dlroW". Input: Geeks for GeeksOutput: skeeG rof skeeG [Expected Appr
      5 min read
    • Reverse a String using Stack
      Given a string str, the task is to reverse it using stack. Example: Input: s = "GeeksQuiz"Output: ziuQskeeG Input: s = "abc"Output: cba Also read: Reverse a String – Complete Tutorial. As we all know, stacks work on the principle of first in, last out. After popping all the elements and placing them
      3 min read
    • Reversing a Queue
      You are given a queue Q, and your task is to reverse the elements of the queue. You are only allowed to use the following standard queue operations: enqueue(x): Add an item x to the rear of the queue.dequeue(): Remove an item from the front of the queue.empty(): Check if the queue is empty or not.Ex
      4 min read

    Intermediate problems on Stack

    • How to create mergeable stack?
      Design a stack with the following operations. push(Stack s, x): Adds an item x to stack s pop(Stack s): Removes the top item from stack s merge(Stack s1, Stack s2): Merge contents of s2 into s1. Time Complexity of all above operations should be O(1). If we use array implementation of the stack, then
      8 min read
    • The Stock Span Problem
      The stock span problem is a financial problem where we have a series of daily price quotes for a stock denoted by an array arr[] and the task is to calculate the span of the stock's price for all days. The span of the stock's price on ith day represents the maximum number of consecutive days leading
      11 min read
    • Next Greater Element (NGE) for every element in given Array
      Given an array arr[] of integers, the task is to find the Next Greater Element for each element of the array in order of their appearance in the array. Note: The Next Greater Element for an element x is the first greater element on the right side of x in the array. Elements for which no greater elem
      9 min read
    • Next Greater Frequency Element
      Given an array, for each element find the value of the nearest element to the right which is having a frequency greater than that of the current element. If there does not exist an answer for a position, then make the value '-1'. Examples: Input: arr[] = [2, 1, 1, 3, 2, 1]Output: [1, -1, -1, 2, 1, -
      9 min read
    • Maximum product of indexes of next greater on left and right
      Given an array arr[1..n], for each element at position i (1 <= i <= n), define the following: left(i) is the closest index j such that j < i and arr[j] > arr[i]. If no such j exists, then left(i) = 0.right(i) is the closest index k such that k > i and arr[k] > arr[i]. If no such k
      11 min read
    • Iterative Tower of Hanoi
      The Tower of Hanoi is a mathematical puzzle with three poles and stacked disks of different sizes. The goal is to move all disks from the source pole to the destination pole using an auxiliary pole, following two rules: Only one disk can be moved at a time.A larger disk cannot be placed on a smaller
      6 min read
    • Sort a stack using a temporary stack
      Given a stack of integers, sort it in ascending order using another temporary stack. Examples: Input: [34, 3, 31, 98, 92, 23]Output: [3, 23, 31, 34, 92, 98]Explanation: After Sorting the given array it would be look like as [3, 23, 31, 34, 92, 98]Input: [3, 5, 1, 4, 2, 8]Output: [1, 2, 3, 4, 5, 8] A
      6 min read
    • Reverse a stack without using extra space in O(n)
      Reverse a Stack without using recursion and extra space. Even the functional Stack is not allowed. Examples: Input : 1->2->3->4 Output : 4->3->2->1 Input : 6->5->4 Output : 4->5->6 We have discussed a way of reversing a stack in the below post.Reverse a Stack using Recu
      6 min read
    • Delete middle element of a stack
      Given a stack with push(), pop(), and empty() operations, The task is to delete the middle element of it without using any additional data structure. Input: s = [10, 20, 30, 40, 50]Output: [50, 40, 20, 10]Explanation: The bottom-most element will be 10 and the top-most element will be 50. Middle ele
      9 min read
    • Check if a queue can be sorted into another queue using a stack
      Given a Queue consisting of first n natural numbers (in random order). The task is to check whether the given Queue elements can be arranged in increasing order in another Queue using a stack. The operation allowed are: Push and pop elements from the stack Pop (Or Dequeue) from the given Queue. Push
      9 min read
    • Check if an array is stack sortable
      Given an array arr[] of n distinct elements, where each element is between 1 and n (inclusive), determine if it is stack-sortable.Note: An array a[] is considered stack-sortable if it can be rearranged into a sorted array b[] using a temporary stack stk with the following operations: Remove the firs
      6 min read
    • Largest Rectangular Area in a Histogram
      Given a histogram represented by an array arr[], where each element of the array denotes the height of the bars in the histogram. All bars have the same width of 1 unit. Task is to find the largest rectangular area possible in a given histogram where the largest rectangle can be made of a number of
      15+ min read
    • Maximum of minimums of every window size in a given array
      Given an integer array arr[] of size n, the task is to find the maximum of the minimums for every window size in the given array, where the window size ranges from 1 to n. Example: Input: arr[] = [10, 20, 30]Output: [30, 20, 10]Explanation: First element in output indicates maximum of minimums of al
      14 min read
    • Find index of closing bracket for a given opening bracket in an expression
      Given a string with brackets. If the start index of the open bracket is given, find the index of the closing bracket. Examples: Input : string = [ABC[23]][89] index = 0 Output : 8 The opening bracket at index 0 corresponds to closing bracket at index 8.Recommended PracticeClosing bracket indexTry It
      7 min read
    • Maximum difference between nearest left and right smaller elements
      Given an array of integers, the task is to find the maximum absolute difference between the nearest left and the right smaller element of every element in the array. Note: If there is no smaller element on right side or left side of any element then we take zero as the smaller element. For example f
      12 min read
    • Delete consecutive same words in a sequence
      Given an array of n strings arr[]. The task is to determine the number of words remaining after pairwise destruction. If two consecutive words in the array are identical, they cancel each other out. This process continues until no more eliminations are possible. Examples: Input: arr[] = ["gfg", "for
      7 min read
    • Check mirror in n-ary tree
      Given two n-ary trees, determine whether they are mirror images of each other. Each tree is described by e edges, where e denotes the number of edges in both trees. Two arrays A[]and B[] are provided, where each array contains 2*e space-separated values representing the edges of both trees. Each edg
      11 min read
    • Reverse a number using stack
      Given a number , write a program to reverse this number using stack. Examples: Input : 365Output : 563Input : 6899Output : 9986We have already discussed the simple method to reverse a number in this post. In this post we will discuss about how to reverse a number using stack.The idea to do this is t
      5 min read
    • Reversing the first K elements of a Queue
      Given an integer k and a queue of integers, The task is to reverse the order of the first k elements of the queue, leaving the other elements in the same relative order. Only following standard operations are allowed on the queue. enqueue(x): Add an item x to rear of queuedequeue(): Remove an item f
      13 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences