-
Notifications
You must be signed in to change notification settings - Fork 19.3k
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Enhance docs, remove main, add tests in
ReverseStack
(#6018)
- Loading branch information
Showing
3 changed files
with
116 additions
and
38 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
83 changes: 45 additions & 38 deletions
83
src/main/java/com/thealgorithms/datastructures/stacks/ReverseStack.java
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -1,67 +1,74 @@ | ||
package com.thealgorithms.datastructures.stacks; | ||
|
||
import java.util.Scanner; | ||
import java.util.Stack; | ||
|
||
/** | ||
* Reversal of a stack using recursion. | ||
* Provides methods to reverse a stack using recursion. | ||
* | ||
* <p>This class includes methods to reverse the order of elements in a stack | ||
* without using additional data structures. Elements are inserted at the bottom | ||
* of the stack to achieve the reverse order. | ||
* | ||
* <p>Example usage: | ||
* <pre> | ||
* Stack<Integer> stack = new Stack<>(); | ||
* stack.push(1); | ||
* stack.push(2); | ||
* stack.push(3); | ||
* ReverseStack.reverseStack(stack); | ||
* </pre> | ||
* After calling {@code reverseStack(stack)}, the stack's order is reversed. | ||
* | ||
* <p>This class is final and has a private constructor to prevent instantiation. | ||
* | ||
* @author Ishika Agarwal, 2021 | ||
*/ | ||
public final class ReverseStack { | ||
private ReverseStack() { | ||
} | ||
|
||
public static void main(String[] args) { | ||
try (Scanner sc = new Scanner(System.in)) { | ||
System.out.println("Enter the number of elements you wish to insert in the stack"); | ||
int n = sc.nextInt(); | ||
int i; | ||
Stack<Integer> stack = new Stack<Integer>(); | ||
System.out.println("Enter the stack elements"); | ||
for (i = 0; i < n; i++) { | ||
stack.push(sc.nextInt()); | ||
} | ||
reverseStack(stack); | ||
System.out.println("The reversed stack is:"); | ||
while (!stack.isEmpty()) { | ||
System.out.print(stack.peek() + ","); | ||
stack.pop(); | ||
} | ||
} | ||
} | ||
|
||
private static void reverseStack(Stack<Integer> stack) { | ||
/** | ||
* Reverses the order of elements in the given stack using recursion. | ||
* Steps: | ||
* 1. Check if the stack is empty. If so, return. | ||
* 2. Pop the top element from the stack. | ||
* 3. Recursively reverse the remaining stack. | ||
* 4. Insert the originally popped element at the bottom of the reversed stack. | ||
* | ||
* @param stack the stack to reverse; should not be null | ||
*/ | ||
public static void reverseStack(Stack<Integer> stack) { | ||
if (stack.isEmpty()) { | ||
return; | ||
} | ||
|
||
// Store the topmost element | ||
int element = stack.peek(); | ||
// Remove the topmost element | ||
stack.pop(); | ||
|
||
// Reverse the stack for the leftover elements | ||
int element = stack.pop(); | ||
reverseStack(stack); | ||
|
||
// Insert the topmost element to the bottom of the stack | ||
insertAtBottom(stack, element); | ||
} | ||
|
||
/** | ||
* Inserts the specified element at the bottom of the stack. | ||
* | ||
* <p>This method is a helper for {@link #reverseStack(Stack)}. | ||
* | ||
* Steps: | ||
* 1. If the stack is empty, push the element and return. | ||
* 2. Remove the top element from the stack. | ||
* 3. Recursively insert the new element at the bottom of the stack. | ||
* 4. Push the removed element back onto the stack. | ||
* | ||
* @param stack the stack in which to insert the element; should not be null | ||
* @param element the element to insert at the bottom of the stack | ||
*/ | ||
private static void insertAtBottom(Stack<Integer> stack, int element) { | ||
if (stack.isEmpty()) { | ||
// When stack is empty, insert the element so it will be present at | ||
// the bottom of the stack | ||
stack.push(element); | ||
return; | ||
} | ||
|
||
int ele = stack.peek(); | ||
// Keep popping elements till stack becomes empty. Push the elements | ||
// once the topmost element has moved to the bottom of the stack. | ||
stack.pop(); | ||
int topElement = stack.pop(); | ||
insertAtBottom(stack, element); | ||
|
||
stack.push(ele); | ||
stack.push(topElement); | ||
} | ||
} |
70 changes: 70 additions & 0 deletions
70
src/test/java/com/thealgorithms/datastructures/stacks/ReverseStackTest.java
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,70 @@ | ||
package com.thealgorithms.datastructures.stacks; | ||
|
||
import static org.junit.jupiter.api.Assertions.assertEquals; | ||
import static org.junit.jupiter.api.Assertions.assertTrue; | ||
|
||
import java.util.Stack; | ||
import org.junit.jupiter.api.Test; | ||
|
||
class ReverseStackTest { | ||
|
||
@Test | ||
void testReverseEmptyStack() { | ||
Stack<Integer> stack = new Stack<>(); | ||
ReverseStack.reverseStack(stack); | ||
assertTrue(stack.isEmpty(), "Reversing an empty stack should result in an empty stack."); | ||
} | ||
|
||
@Test | ||
void testReverseSingleElementStack() { | ||
Stack<Integer> stack = new Stack<>(); | ||
stack.push(1); | ||
ReverseStack.reverseStack(stack); | ||
assertEquals(1, stack.peek(), "Reversing a single-element stack should have the same element on top."); | ||
} | ||
|
||
@Test | ||
void testReverseTwoElementStack() { | ||
Stack<Integer> stack = new Stack<>(); | ||
stack.push(1); | ||
stack.push(2); | ||
ReverseStack.reverseStack(stack); | ||
|
||
assertEquals(1, stack.pop(), "After reversal, the stack's top element should be the first inserted element."); | ||
assertEquals(2, stack.pop(), "After reversal, the stack's next element should be the second inserted element."); | ||
} | ||
|
||
@Test | ||
void testReverseMultipleElementsStack() { | ||
Stack<Integer> stack = new Stack<>(); | ||
stack.push(1); | ||
stack.push(2); | ||
stack.push(3); | ||
stack.push(4); | ||
|
||
ReverseStack.reverseStack(stack); | ||
|
||
assertEquals(1, stack.pop(), "Stack order after reversal should match the initial push order."); | ||
assertEquals(2, stack.pop()); | ||
assertEquals(3, stack.pop()); | ||
assertEquals(4, stack.pop()); | ||
} | ||
|
||
@Test | ||
void testReverseStackAndVerifySize() { | ||
Stack<Integer> stack = new Stack<>(); | ||
stack.push(10); | ||
stack.push(20); | ||
stack.push(30); | ||
stack.push(40); | ||
int originalSize = stack.size(); | ||
|
||
ReverseStack.reverseStack(stack); | ||
|
||
assertEquals(originalSize, stack.size(), "Stack size should remain unchanged after reversal."); | ||
assertEquals(10, stack.pop(), "Reversal should place the first inserted element on top."); | ||
assertEquals(20, stack.pop()); | ||
assertEquals(30, stack.pop()); | ||
assertEquals(40, stack.pop()); | ||
} | ||
} |