Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Reverse a number using stack

  • Difficulty Level : Easy
  • Last Updated : 23 Jul, 2021

Given a number , write a program to reverse this number using stack.
Examples: 
 

Input : 365
Output : 563

Input : 6899
Output : 9986

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

We 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 to extract digits of the number and push the digits on to a stack. Once all of the digits of the number are pushed to the stack, we will start poping the contents of stack one by one and form a number. 
As stack is a LIFO data structure, digits of the newly formed number will be in reverse order.
Below is the implementation of above idea: 
 

C++




// CPP program to reverse the number
// using a stack
 
#include <bits/stdc++.h>
using namespace std;
 
// Stack to maintain order of digits
stack <int> st;
 
// Function to push digits into stack
void push_digits(int number)
{
    while (number != 0)
    {
        st.push(number % 10);
        number = number / 10;
    }
}
 
// Function to reverse the number
int reverse_number(int number)
{
    // Function call to push number's
    // digits to stack
    push_digits(number);
     
    int reverse = 0;
    int i = 1;
     
    // Popping the digits and forming
    // the reversed number
    while (!st.empty())
    {
        reverse = reverse + (st.top() * i);
        st.pop();
        i = i * 10;
    }
     
    // Return the reversed number formed
    return reverse;
}
 
// Driver program to test above function
int main()
{
    int number = 39997;
     
    // Function call to reverse number
    cout << reverse_number(number);
     
    return 0;
}

Java




// Java program to reverse the number
// using a stack
import java.util.Stack;
 
public class GFG
{
    // Stack to maintain order of digits
    static Stack<Integer> st= new Stack<>();
 
    // Function to push digits into stack
    static void push_digits(int number)
    {
        while(number != 0)
        {
            st.push(number % 10);
            number = number / 10;
        }
    }
 
    // Function to reverse the number
    static int reverse_number(int number)
    {
        // Function call to push number's
        // digits to stack
        push_digits(number);
        int reverse = 0;
        int i = 1;
 
        // Popping the digits and forming
        // the reversed number
        while (!st.isEmpty())
        {
            reverse = reverse + (st.peek() * i);
            st.pop();
            i = i * 10;
        }
 
        // Return the reversed number formed
        return reverse;
    }
 
    // Driver program to test above function
    public static void main(String[] args)
    {
        int number = 39997;
        System.out.println(reverse_number(number));
    }
}
// This code is contributed by Sumit Ghosh

Python3




# Python3 program to reverse the
# number using a stack
 
# Stack to maintain order of digits
st = [];
 
# Function to push digits into stack
def push_digits(number):
 
    while (number != 0):
        st.append(number % 10);
        number = int(number / 10);
 
# Function to reverse the number
def reverse_number(number):
     
    # Function call to push number's
    # digits to stack
    push_digits(number);
     
    reverse = 0;
    i = 1;
     
    # Popping the digits and forming
    # the reversed number
    while (len(st) > 0):
        reverse = reverse + (st[len(st) - 1] * i);
        st.pop();
        i = i * 10;
     
    # Return the reversed number formed
    return reverse;
 
# Driver Code
number = 39997;
 
# Function call to reverse number
print(reverse_number(number));
 
# This code is contributed by mits

C#




// C# program to reverse the number
// using a stack
using System;
using System.Collections.Generic;
 
class GFG
{
// Stack to maintain order of digits
public static Stack<int> st = new Stack<int>();
 
// Function to push digits into stack
public static void push_digits(int number)
{
    while (number != 0)
    {
        st.Push(number % 10);
        number = number / 10;
    }
}
 
// Function to reverse the number
public static int reverse_number(int number)
{
    // Function call to push number's
    // digits to stack
    push_digits(number);
    int reverse = 0;
    int i = 1;
 
    // Popping the digits and forming
    // the reversed number
    while (st.Count > 0)
    {
        reverse = reverse + (st.Peek() * i);
        st.Pop();
        i = i * 10;
    }
 
    // Return the reversed number formed
    return reverse;
}
 
// Driver Code
public static void Main(string[] args)
{
    int number = 39997;
    Console.WriteLine(reverse_number(number));
}
}
 
// This code is contributed by Shrikant13

PHP




<?php
// PHP program to reverse the number
// using a stack
 
// Stack to maintain order of digits
$st = array();
 
// Function to push digits into stack
function push_digits($number)
{
    global $st;
    while ($number != 0)
    {
        array_push($st, $number % 10);
        $number = (int)($number / 10);
    }
}
 
// Function to reverse the number
function reverse_number($number)
{
    global $st;
     
    // Function call to push number's
    // digits to stack
    push_digits($number);
     
    $reverse = 0;
    $i = 1;
     
    // Popping the digits and forming
    // the reversed number
    while (!empty($st))
    {
        $reverse = $reverse +
                  ($st[count($st) - 1] * $i);
        array_pop($st);
        $i = $i * 10;
    }
     
    // Return the reversed number formed
    return $reverse;
}
 
// Driver Code
$number = 39997;
 
// Function call to reverse number
echo reverse_number($number);
 
// This code is contributed by mits
?>

Javascript




<script>
 // JavaScript program for the above approach
 
        // Stack to maintain order of digits
        let st = [];
 
        // Function to push digits into stack
        function push_digits(number)
        {
            while (number != 0)
            {
                st.push(number % 10);
                number = Math.floor(number / 10);
            }
        }
 
        // Function to reverse the number
        function reverse_number(number)
        {
         
            // Function call to push number's
            // digits to stack
            push_digits(number);
 
            let reverse = 0;
            let i = 1;
 
            // Popping the digits and forming
            // the reversed number
            while (st.length != 0) {
                reverse = reverse + (st[st.length - 1] * i);
                st.pop();
                i = i * 10;
            }
 
            // Return the reversed number formed
            return reverse;
        }
 
        // Driver program to test above function
        let number = 39997;
 
        // Function call to reverse number
        document.write(reverse_number(number));
 
// This code is contributed by Potta Lokesh
</script>

Output: 
 



79993

Time Complexity: O( logN ) 
Auxiliary Space: O( logN ), Where N is the input number.
 

This article is contributed by Rohit Thapliyal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!