Reverse a number using stack

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

Examples:

Input : 365
Output : 563

Input : 6899
Output : 9986

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 popping 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.

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.