From dbcae3e6db2034e480420fc6662fc73b5ae1c987 Mon Sep 17 00:00:00 2001 From: Hardik Pawar Date: Mon, 7 Oct 2024 15:08:17 +0530 Subject: [PATCH 1/5] Add `SortStack.java` new algorithm --- .../com/thealgorithms/stacks/SortStack.java | 42 ++++++++++ .../thealgorithms/stacks/SortStackTest.java | 77 +++++++++++++++++++ 2 files changed, 119 insertions(+) create mode 100644 src/main/java/com/thealgorithms/stacks/SortStack.java create mode 100644 src/test/java/com/thealgorithms/stacks/SortStackTest.java diff --git a/src/main/java/com/thealgorithms/stacks/SortStack.java b/src/main/java/com/thealgorithms/stacks/SortStack.java new file mode 100644 index 000000000000..150bf753c0c4 --- /dev/null +++ b/src/main/java/com/thealgorithms/stacks/SortStack.java @@ -0,0 +1,42 @@ +package com.thealgorithms.stacks; + +import java.util.Stack; + +/** + * Class that provides a method to sort a stack using recursion. + */ +public class SortStack { + + /** + * Sorts the provided stack using recursion. This method modifies the original stack + * so that the elements are arranged in ascending order (largest on top). + * + * @param stack The stack to be sorted. + */ + public static void sortStack(Stack stack) { + if (stack.isEmpty()) { + return; + } + + int top = stack.pop(); + sortStack(stack); + insertInSortedOrder(stack, top); + } + + /** + * Inserts an element into the sorted stack at the correct position. + * + * @param stack The stack in which the element needs to be inserted. + * @param element The element to be inserted in sorted order. + */ + private static void insertInSortedOrder(Stack stack, int element) { + if (stack.isEmpty() || element > stack.peek()) { + stack.push(element); + return; + } + + int top = stack.pop(); + insertInSortedOrder(stack, element); + stack.push(top); + } +} diff --git a/src/test/java/com/thealgorithms/stacks/SortStackTest.java b/src/test/java/com/thealgorithms/stacks/SortStackTest.java new file mode 100644 index 000000000000..b9f2f1b6f106 --- /dev/null +++ b/src/test/java/com/thealgorithms/stacks/SortStackTest.java @@ -0,0 +1,77 @@ +package com.thealgorithms.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.BeforeEach; +import org.junit.jupiter.api.Test; + +public class SortStackTest { + + private Stack stack; + + @BeforeEach + public void setUp() { + stack = new Stack<>(); + } + + @Test + public void testSortEmptyStack() { + SortStack.sortStack(stack); + assertTrue(stack.isEmpty()); // An empty stack should remain empty + } + + @Test + public void testSortSingleElementStack() { + stack.push(10); + SortStack.sortStack(stack); + assertEquals(1, stack.size()); + assertEquals(10, (int) stack.peek()); // Single element should remain unchanged + } + + @Test + public void testSortAlreadySortedStack() { + stack.push(1); + stack.push(2); + stack.push(3); + stack.push(4); + SortStack.sortStack(stack); + + assertEquals(4, stack.size()); + assertEquals(4, (int) stack.pop()); + assertEquals(3, (int) stack.pop()); + assertEquals(2, (int) stack.pop()); + assertEquals(1, (int) stack.pop()); + } + + @Test + public void testSortUnsortedStack() { + stack.push(3); + stack.push(1); + stack.push(4); + stack.push(2); + SortStack.sortStack(stack); + + assertEquals(4, stack.size()); + assertEquals(4, (int) stack.pop()); + assertEquals(3, (int) stack.pop()); + assertEquals(2, (int) stack.pop()); + assertEquals(1, (int) stack.pop()); + } + + @Test + public void testSortWithDuplicateElements() { + stack.push(3); + stack.push(1); + stack.push(3); + stack.push(2); + SortStack.sortStack(stack); + + assertEquals(4, stack.size()); + assertEquals(3, (int) stack.pop()); + assertEquals(3, (int) stack.pop()); + assertEquals(2, (int) stack.pop()); + assertEquals(1, (int) stack.pop()); + } +} From 613d552db0e926112ec315a732a30644de8b1df0 Mon Sep 17 00:00:00 2001 From: Hardik Pawar Date: Mon, 7 Oct 2024 15:09:11 +0530 Subject: [PATCH 2/5] Improve documentation --- .../com/thealgorithms/stacks/SortStack.java | 28 +++++++++++++++---- 1 file changed, 22 insertions(+), 6 deletions(-) diff --git a/src/main/java/com/thealgorithms/stacks/SortStack.java b/src/main/java/com/thealgorithms/stacks/SortStack.java index 150bf753c0c4..a012d1862676 100644 --- a/src/main/java/com/thealgorithms/stacks/SortStack.java +++ b/src/main/java/com/thealgorithms/stacks/SortStack.java @@ -3,15 +3,25 @@ import java.util.Stack; /** - * Class that provides a method to sort a stack using recursion. + * A utility class that provides a method to sort a stack using recursion. + * The elements are sorted in ascending order, with the largest element at the top. + * This algorithm is implemented using only recursion and the original stack, + * without utilizing any additional data structures apart from the stack itself. */ public class SortStack { /** - * Sorts the provided stack using recursion. This method modifies the original stack - * so that the elements are arranged in ascending order (largest on top). + * Sorts the given stack in ascending order using recursion. + * The sorting is performed such that the largest element ends up on top of the stack. + * This method modifies the original stack and does not return a new stack. * - * @param stack The stack to be sorted. + * The algorithm works as follows: + * 1. Remove the top element. + * 2. Recursively sort the remaining stack. + * 3. Insert the removed element back into the sorted stack at the correct position. + * + * @param stack The stack to be sorted, containing Integer elements. + * @throws IllegalArgumentException if the stack contains `null` elements. */ public static void sortStack(Stack stack) { if (stack.isEmpty()) { @@ -24,10 +34,16 @@ public static void sortStack(Stack stack) { } /** - * Inserts an element into the sorted stack at the correct position. + * Helper method to insert an element into the correct position in a sorted stack. + * This method is called recursively to place the given element into the stack + * such that the stack remains sorted in ascending order. + * + * The element is inserted in such a way that all elements below it are smaller + * (if the stack is non-empty), and elements above it are larger, maintaining + * the ascending order. * * @param stack The stack in which the element needs to be inserted. - * @param element The element to be inserted in sorted order. + * @param element The element to be inserted into the stack in sorted order. */ private static void insertInSortedOrder(Stack stack, int element) { if (stack.isEmpty() || element > stack.peek()) { From 7bd23b53a35367ebf6fc87133b54774678576a6e Mon Sep 17 00:00:00 2001 From: Hardvan Date: Mon, 7 Oct 2024 09:39:31 +0000 Subject: [PATCH 3/5] Update directory --- DIRECTORY.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/DIRECTORY.md b/DIRECTORY.md index 1bad5d3b98a3..6fc55a70dffd 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -551,6 +551,7 @@ * [NextSmallerElement](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/NextSmallerElement.java) * [PostfixToInfix](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PostfixToInfix.java) * [PrefixToInfix](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PrefixToInfix.java) + * [SortStack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/SortStack.java) * [StackPostfixNotation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/StackPostfixNotation.java) * strings * [AhoCorasick](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/strings/AhoCorasick.java) @@ -987,6 +988,7 @@ * [NextSmallerElementTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/NextSmallerElementTest.java) * [PostfixToInfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PostfixToInfixTest.java) * [PrefixToInfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PrefixToInfixTest.java) + * [SortStackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/SortStackTest.java) * [StackPostfixNotationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/StackPostfixNotationTest.java) * strings * [AhoCorasickTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/strings/AhoCorasickTest.java) From 31f967ba5577c8bafd7bf98db9ec9999043d4294 Mon Sep 17 00:00:00 2001 From: Hardik Pawar Date: Mon, 7 Oct 2024 15:32:19 +0530 Subject: [PATCH 4/5] Fix --- src/main/java/com/thealgorithms/stacks/SortStack.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/stacks/SortStack.java b/src/main/java/com/thealgorithms/stacks/SortStack.java index a012d1862676..d07d1a5f1dc3 100644 --- a/src/main/java/com/thealgorithms/stacks/SortStack.java +++ b/src/main/java/com/thealgorithms/stacks/SortStack.java @@ -8,7 +8,9 @@ * This algorithm is implemented using only recursion and the original stack, * without utilizing any additional data structures apart from the stack itself. */ -public class SortStack { +public final class SortStack { + private SortStack() { + } /** * Sorts the given stack in ascending order using recursion. From 3100e3b8354781f2b93acc68a812f7e7240539a6 Mon Sep 17 00:00:00 2001 From: siriak Date: Tue, 8 Oct 2024 15:48:19 +0000 Subject: [PATCH 5/5] Update directory --- DIRECTORY.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/DIRECTORY.md b/DIRECTORY.md index 35d7f1fc5c74..9fb1112924f3 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -267,6 +267,7 @@ * [SumOfSubset](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/SumOfSubset.java) * [Tribonacci](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/Tribonacci.java) * [UniquePaths](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/UniquePaths.java) + * [UniqueSubsequencesCount](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCount.java) * [WildcardMatching](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/WildcardMatching.java) * [WineProblem](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/WineProblem.java) * geometry @@ -795,6 +796,7 @@ * [SumOfSubsetTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/SumOfSubsetTest.java) * [TribonacciTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/TribonacciTest.java) * [UniquePathsTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/UniquePathsTests.java) + * [UniqueSubsequencesCountTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java) * [WildcardMatchingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/WildcardMatchingTest.java) * geometry * [GrahamScanTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/geometry/GrahamScanTest.java)