Added TowerofHanoi and its test file to recursion

Author: justanothercoder-hub

src/main/java/com/thealgorithms/recursion/TowerofHanoi.java

@@ -0,0 +1,76 @@
+package com.thealgorithms.recursion;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ * TowerOfHanoi - Solves the classic Tower of Hanoi puzzle
+ *
+ * This algorithm uses recursion to move a stack of disks from a source rod to a
+ * destination rod, following the rules:
+ * 1. Only one disk can be moved at a time.
+ * 2. Each move consists of taking the upper disk from one of the stacks and
+ * placing it on top of another stack.
+ * 3. No disk may be placed on top of a smaller disk.
+ *
+ * Example: If n = 3, Source = 'A', Destination = 'C', Auxiliary = 'B'
+ * Resulting moves will guide disks from A to C using B.
+ *
+ * @author justanothercoder
+ * @see <a href="https://en.wikipedia.org/wiki/Tower_of_Hanoi">Tower of Hanoi</a>
+ */
+public final class TowerofHanoi {
+
+    private TowerofHanoi() {
+
+        // Utility class
+    }
+
+    /**
+     * Solves the Tower of Hanoi puzzle and returns the list of moves
+     *
+     * @param n number of disks
+     * @param source the source rod
+     * @param destination the destination rod
+     * @param auxiliary the auxiliary rod
+     * @return list of moves as strings
+     */
+    public static List<String> solveTowerOfHanoi(int n, char source, char destination, char auxiliary) {
+        List<String> moves = new ArrayList<>();
+        if(n<0){
+            throw new IllegalArgumentException("Number of disks cannot be negative");
+        }
+        moveDisks(n, source, destination, auxiliary, moves);
+        return moves;
+    }
+
+    /**
+     * Recursive helper method to move disks
+     *
+     * @param n number of disks
+     * @param source the source rod
+     * @param destination the destination rod
+     * @param auxiliary the auxiliary rod
+     * @param moves list to record the moves
+     */
+    private static void moveDisks(int n, char source, char destination, char auxiliary, List<String> moves) {
+        if (n == 1) {
+            moves.add("Move disk 1 from rod " + source + " to rod " + destination);
+            return;
+        }
+        moveDisks(n - 1, source, auxiliary, destination, moves);
+        moves.add("Move disk " + n + " from rod " + source + " to rod " + destination);
+        moveDisks(n - 1, auxiliary, destination, source, moves);
+    }
+
+    public static void main(String[] args){
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Enter the number of disks: ");
+        int n = scanner.nextInt();
+        List<String> result = solveTowerOfHanoi(n, 'A', 'C', 'B');
+
+        for(String move: result){
+            System.out.println(move);
+        }
+    }

src/test/java/com/thealgorithms/recursion/TowerofHanoiTest.java

@@ -0,0 +1,74 @@
+package com.thealgorithms.recursion;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import java.util.Arrays;
+import java.util.List;
+
+public class TowerOfHanoiTest {
+
+    /**
+     * Test Case 1: Base Case (n = 1)
+     * Requirement: Explicitly requested.
+     * Logic: With only 1 disk, it should move directly from Source (A) to Destination (C).
+     */
+    @Test
+    public void testBaseCase() {
+        List<String> result = TowerOfHanoi.solveTowerOfHanoi(1, 'A', 'C', 'B');
+        
+        // Assertion 1: Check size (2^1 - 1 = 1 move)
+        assertEquals(1, result.size(), "Should have exactly 1 move for 1 disk");
+        
+        // Assertion 2: Verify the exact string
+        assertEquals("Move disk 1 from rod A to rod C", result.get(0));
+    }
+
+    /**
+     * Test Case 2: Small Recursion (n = 2)
+     * Logic: Tests the basic recursive step (Move 1 to Aux, Move 2 to Dest, Move 1 to Dest).
+     */
+    @Test
+    public void testSmallRecursion() {
+        List<String> result = TowerOfHanoi.solveTowerOfHanoi(2, 'A', 'C', 'B');
+        
+        // Assertion 1: Check size (2^2 - 1 = 3 moves)
+        assertEquals(3, result.size());
+        
+        // Assertion 2: Verify the exact sequence of moves
+        List<String> expected = Arrays.asList(
+            "Move disk 1 from rod A to rod B", // Small disk to Aux
+            "Move disk 2 from rod A to rod C", // Big disk to Dest
+            "Move disk 1 from rod B to rod C"  // Small disk to Dest
+        );
+        
+        assertEquals(expected, result, "Sequence of moves for 2 disks is incorrect");
+    }
+
+    /**
+     * Test Case 3: Standard Case (n = 3)
+     * Logic: Verifies a slightly larger recursion to ensure the stack depth works correctly.
+     */
+    @Test
+    public void testStandardCase() {
+        List<String> result = TowerOfHanoi.solveTowerOfHanoi(3, 'A', 'C', 'B');
+        
+        // Assertion 1: Check size (2^3 - 1 = 7 moves)
+        assertEquals(7, result.size());
+        
+        // Assertion 2: Verify start and end moves specifically
+        assertEquals("Move disk 1 from rod A to rod C", result.get(0)); // First move
+        assertEquals("Move disk 1 from rod A to rod C", result.get(6)); // Last move
+    }
+
+    /**
+     * Extra Test Case: Negative Input
+     * Logic: Ensures your "Defensive Programming" check works.
+     */
+    @Test
+    public void testNegativeInput() {
+        assertThrows(IllegalArgumentException.class, () -> {
+            TowerOfHanoi.solveTowerOfHanoi(-5, 'A', 'C', 'B');
+        }, "Should throw exception for negative disks");
+    }
+}