Reverse A Number In Java Using Recursion

Reversing a number is a common programming challenge that can be solved in several ways. Recursion offers an elegant and concise approach to this problem. In this article, you will learn how to reverse a number in Java using a recursive method.

Problem Statement

The goal is to take an integer as input and return a new integer with its digits reversed. For example, if the input is 123, the output should be 321. This operation needs to handle various digit counts and maintain the numerical value of the reversed sequence.

Example

If the input number is 4567, the reversed number should be 7654.

Background & Knowledge Prerequisites

To understand this article, you should have a basic understanding of:

• Java fundamentals: Variables, data types, and basic arithmetic operations.
• Methods: How to define and call methods in Java.
• Recursion: The concept of a method calling itself, including base cases and recursive steps.

Use Cases or Case Studies

Reversing numbers can be useful in various scenarios:

• Palindrome checking: Determining if a number reads the same forwards and backward (e.g., 121).
• Mathematical puzzles: Solving problems that involve manipulating digits of a number.
• Algorithm practice: A classic problem for practicing recursion and iterative solutions.
• Data transformation: In some specific data processing tasks, reversing numerical sequences might be required.
• Educational exercises: Often used to teach fundamental programming concepts.

Solution Approaches

We will focus on a recursive approach to reverse a number.

Recursive Approach

This approach uses a method that calls itself, breaking down the problem into smaller, similar subproblems.

• One-line summary: Recursively extracts the last digit and builds the reversed number by placing it at the beginning of the remaining reversed digits.

// Reverse a Number Using Recursion
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {

    // Helper variable to store the reversed number
    static int reversedNumber = 0;

    // Recursive method to reverse a number
    public static void reverseNumber(int number) {
        // Base case: if the number becomes 0, stop recursion
        if (number == 0) {
            return;
        }

        // Step 1: Get the last digit of the number
        int lastDigit = number % 10;

        // Step 2: Append the last digit to the reversedNumber
        reversedNumber = reversedNumber * 10 + lastDigit;

        // Step 3: Recursively call the method with the remaining digits
        reverseNumber(number / 10);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Step 1: Prompt the user to enter a number
        System.out.print("Enter a number to reverse: ");
        int num = scanner.nextInt();

        // Step 2: Call the recursive method to reverse the number
        reverseNumber(num);

        // Step 3: Print the reversed number
        System.out.println("Reversed number: " + reversedNumber);

        scanner.close();
    }
}

Run

• Sample Output:

Enter a number to reverse: 12345
Reversed number: 54321

• Stepwise Explanation:

1. reversedNumber variable: A static variable reversedNumber is initialized to 0. This variable will accumulate the reversed digits.
2. reverseNumber(int number) method:

• Base Case: If number becomes 0, it means all digits have been processed, so the recursion stops (return;).
• Extract Last Digit: int lastDigit = number % 10; extracts the last digit of the current number. For 123, lastDigit would be 3.
• Build Reversed Number: reversedNumber = reversedNumber * 10 + lastDigit; takes the current reversedNumber, multiplies it by 10 (to shift existing digits to the left), and then adds the lastDigit.
• Initially: reversedNumber = 0 * 10 + 3 = 3
• Next call: reversedNumber = 3 * 10 + 2 = 32
• Next call: reversedNumber = 32 * 10 + 1 = 321
• Recursive Call: reverseNumber(number / 10); makes a recursive call with the number divided by 10. This effectively removes the last digit, preparing for the next iteration. For 123, number / 10 becomes 12, then 1, then 0.

1. main method:

• It takes an integer input from the user.
• It calls the reverseNumber method with the input.
• Finally, it prints the reversedNumber which holds the result.

Conclusion

Recursion provides an elegant way to reverse a number by repeatedly extracting the last digit and building the reversed number. The base case ensures the recursion terminates, and each recursive step processes one digit until the number is fully reversed.

Summary

• Problem: Reverse the digits of an integer.
• Recursive Approach:
• A static helper variable accumulates the reversed number.
• The base case for recursion is when the input number becomes 0.
• In each recursive step, the last digit is extracted, appended to the reversedNumber, and the method is called again with the remaining digits (number / 10).