From d94c96c999aff83baf803fbc577b9628bce35210 Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 10:09:18 +0530 Subject: [PATCH 01/13] Add MonotonicStack class with element retrieval methods --- .../stacks/Monotonic_Increasing_Stack.java | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 src/test/java/com/thealgorithms/stacks/Monotonic_Increasing_Stack.java diff --git a/src/test/java/com/thealgorithms/stacks/Monotonic_Increasing_Stack.java b/src/test/java/com/thealgorithms/stacks/Monotonic_Increasing_Stack.java new file mode 100644 index 000000000000..e9f346ca3ca5 --- /dev/null +++ b/src/test/java/com/thealgorithms/stacks/Monotonic_Increasing_Stack.java @@ -0,0 +1,55 @@ +import java.util.*; + +public class MonotonicStack { + + // Returns Next Greater Element for each element in the array + public static int[] nextGreaterElement(int[] arr) { + int n = arr.length; + int[] result = new int[n]; + Stack stack = new Stack<>(); // stores indices + + for (int i = n - 1; i >= 0; i--) { + // Pop elements smaller or equal to arr[i] + while (!stack.isEmpty() && arr[i] >= arr[stack.peek()]) { + stack.pop(); + } + + // If stack is empty, no greater element to the right + result[i] = stack.isEmpty() ? -1 : arr[stack.peek()]; + + // Push current index onto stack + stack.push(i); + } + + return result; + } + + // Returns Next Smaller Element for each element in the array + public static int[] nextSmallerElement(int[] arr) { + int n = arr.length; + int[] result = new int[n]; + Stack stack = new Stack<>(); // stores indices + + for (int i = n - 1; i >= 0; i--) { + // Pop elements greater or equal to arr[i] + while (!stack.isEmpty() && arr[i] <= arr[stack.peek()]) { + stack.pop(); + } + + result[i] = stack.isEmpty() ? -1 : arr[stack.peek()]; + stack.push(i); + } + + return result; + } + + public static void main(String[] args) { + int[] arr = {4, 5, 2, 10, 8}; + + int[] nextGreater = nextGreaterElement(arr); + int[] nextSmaller = nextSmallerElement(arr); + + System.out.println("Next Greater Element: " + Arrays.toString(nextGreater)); + System.out.println("Next Smaller Element: " + Arrays.toString(nextSmaller)); + } +} From 8bd26a1afe9e85c342596a2097e578390e1982ae Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 10:12:15 +0530 Subject: [PATCH 02/13] Rename Monotonic_Increasing_Stack.java to MonotonicIncreasingStack.java --- ...otonic_Increasing_Stack.java => MonotonicIncreasingStack.java} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/test/java/com/thealgorithms/stacks/{Monotonic_Increasing_Stack.java => MonotonicIncreasingStack.java} (100%) diff --git a/src/test/java/com/thealgorithms/stacks/Monotonic_Increasing_Stack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java similarity index 100% rename from src/test/java/com/thealgorithms/stacks/Monotonic_Increasing_Stack.java rename to src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java From 8cfd530dc59cdd049944b805528d8e3e5a461cd1 Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 10:13:49 +0530 Subject: [PATCH 03/13] Add comments to MonotonicIncreasingStack.java Added a comment block explaining the Monotonic Increasing Stack algorithm and its applications. --- .../com/thealgorithms/stacks/MonotonicIncreasingStack.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index e9f346ca3ca5..58d653e0666d 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -1,3 +1,9 @@ +/*Contributor: Nayan Saraff + +This Monotonic Increasing Stack is a popular algorithm which helps +in solving various problems including the Stock Span, Trapping Rain water*/ + + import java.util.*; public class MonotonicStack { From e52b2edae71c51b17dd0560a95452297a8477d34 Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 10:16:09 +0530 Subject: [PATCH 04/13] Add reference link for monotonic stack implementation Added a comment with a reference link for monotonic stack. --- .../java/com/thealgorithms/stacks/MonotonicIncreasingStack.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index 58d653e0666d..aad1603b6169 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -59,3 +59,5 @@ public static void main(String[] args) { System.out.println("Next Smaller Element: " + Arrays.toString(nextSmaller)); } } + +/* https://www.geeksforgeeks.org/dsa/introduction-to-monotonic-stack-2/ */ From 1debee090e18e4876953a456e22d667f40d13b2b Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 10:28:45 +0530 Subject: [PATCH 05/13] Rename MonotonicStack to MonotonicIncreasingStack --- .../java/com/thealgorithms/stacks/MonotonicIncreasingStack.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index aad1603b6169..72b8ef48ed0c 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -6,7 +6,7 @@ import java.util.*; -public class MonotonicStack { +public class MonotonicIncreasingStack { // Returns Next Greater Element for each element in the array public static int[] nextGreaterElement(int[] arr) { From 3d026b5269e4c20f5db6fef19ab14cff39f26691 Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 10:31:53 +0530 Subject: [PATCH 06/13] Fix comments and formatting in MonotonicIncreasingStack --- .../stacks/MonotonicIncreasingStack.java | 50 ++++++++++--------- 1 file changed, 26 insertions(+), 24 deletions(-) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index 72b8ef48ed0c..8aceb02e4ab9 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -1,44 +1,45 @@ -/*Contributor: Nayan Saraff +/* Contributor: Nayan Saraff + * + * This Monotonic Increasing Stack is a popular algorithm which helps + * in solving various problems including Stock Span, Trapping Rain Water + */ -This Monotonic Increasing Stack is a popular algorithm which helps -in solving various problems including the Stock Span, Trapping Rain water*/ +import java.util.Arrays; +import java.util.Stack; +public class MonotonicIncreasingStack +{ -import java.util.*; - -public class MonotonicIncreasingStack { - - // Returns Next Greater Element for each element in the array - public static int[] nextGreaterElement(int[] arr) { + public static int[] nextGreaterElement(int[] arr) + { int n = arr.length; int[] result = new int[n]; - Stack stack = new Stack<>(); // stores indices + Stack stack = new Stack<>(); - for (int i = n - 1; i >= 0; i--) { - // Pop elements smaller or equal to arr[i] - while (!stack.isEmpty() && arr[i] >= arr[stack.peek()]) { + for (int i = n - 1; i >= 0; i--) + { + while (!stack.isEmpty() && arr[i] >= arr[stack.peek()]) + { stack.pop(); } - // If stack is empty, no greater element to the right result[i] = stack.isEmpty() ? -1 : arr[stack.peek()]; - - // Push current index onto stack stack.push(i); } return result; } - // Returns Next Smaller Element for each element in the array - public static int[] nextSmallerElement(int[] arr) { + public static int[] nextSmallerElement(int[] arr) + { int n = arr.length; int[] result = new int[n]; - Stack stack = new Stack<>(); // stores indices + Stack stack = new Stack<>(); - for (int i = n - 1; i >= 0; i--) { - // Pop elements greater or equal to arr[i] - while (!stack.isEmpty() && arr[i] <= arr[stack.peek()]) { + for (int i = n - 1; i >= 0; i--) + { + while (!stack.isEmpty() && arr[i] <= arr[stack.peek()]) + { stack.pop(); } @@ -49,7 +50,8 @@ public static int[] nextSmallerElement(int[] arr) { return result; } - public static void main(String[] args) { + public static void main(String[] args) + { int[] arr = {4, 5, 2, 10, 8}; int[] nextGreater = nextGreaterElement(arr); @@ -60,4 +62,4 @@ public static void main(String[] args) { } } -/* https://www.geeksforgeeks.org/dsa/introduction-to-monotonic-stack-2/ */ +/* Reference: https://www.geeksforgeeks.org/dsa/introduction-to-monotonic-stack-2/ */ From af850320566506eadb5ec19f2b01b5bc9a2ee362 Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 10:43:40 +0530 Subject: [PATCH 07/13] Refactor MonotonicIncreasingStack for utility class --- .../stacks/MonotonicIncreasingStack.java | 32 +++++++------------ 1 file changed, 12 insertions(+), 20 deletions(-) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index 8aceb02e4ab9..66567faeac8f 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -7,51 +7,43 @@ import java.util.Arrays; import java.util.Stack; -public class MonotonicIncreasingStack -{ +public class MonotonicIncreasingStack { - public static int[] nextGreaterElement(int[] arr) - { + private MonotonicIncreasingStack() { + throw new AssertionError("Cannot instantiate utility class"); + } + + public static int[] nextGreaterElement(int[] arr) { int n = arr.length; int[] result = new int[n]; Stack stack = new Stack<>(); - for (int i = n - 1; i >= 0; i--) - { - while (!stack.isEmpty() && arr[i] >= arr[stack.peek()]) - { + for (int i = n - 1; i >= 0; i--) { + while (!stack.isEmpty() && arr[i] >= arr[stack.peek()]) { stack.pop(); } - result[i] = stack.isEmpty() ? -1 : arr[stack.peek()]; stack.push(i); } - return result; } - public static int[] nextSmallerElement(int[] arr) - { + public static int[] nextSmallerElement(int[] arr) { int n = arr.length; int[] result = new int[n]; Stack stack = new Stack<>(); - for (int i = n - 1; i >= 0; i--) - { - while (!stack.isEmpty() && arr[i] <= arr[stack.peek()]) - { + for (int i = n - 1; i >= 0; i--) { + while (!stack.isEmpty() && arr[i] <= arr[stack.peek()]) { stack.pop(); } - result[i] = stack.isEmpty() ? -1 : arr[stack.peek()]; stack.push(i); } - return result; } - public static void main(String[] args) - { + public static void main(String[] args) { int[] arr = {4, 5, 2, 10, 8}; int[] nextGreater = nextGreaterElement(arr); From e606da35457ef282ee3423e6e619bc189e254163 Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 10:47:32 +0530 Subject: [PATCH 08/13] Change class declaration to final for MonotonicIncreasingStack --- .../java/com/thealgorithms/stacks/MonotonicIncreasingStack.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index 66567faeac8f..b2adf0dd97da 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -7,7 +7,7 @@ import java.util.Arrays; import java.util.Stack; -public class MonotonicIncreasingStack { +public class final MonotonicIncreasingStack { private MonotonicIncreasingStack() { throw new AssertionError("Cannot instantiate utility class"); From efe19adf51ea7c40e79b30e839d5e0e59f2f6523 Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 10:50:41 +0530 Subject: [PATCH 09/13] Fix class declaration for MonotonicIncreasingStack --- .../java/com/thealgorithms/stacks/MonotonicIncreasingStack.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index b2adf0dd97da..3ee512ca7d5e 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -7,7 +7,7 @@ import java.util.Arrays; import java.util.Stack; -public class final MonotonicIncreasingStack { +public final class MonotonicIncreasingStack { private MonotonicIncreasingStack() { throw new AssertionError("Cannot instantiate utility class"); From 6b91248a5add9ca4958dad6c5717df0294ba7fc3 Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 10:58:28 +0530 Subject: [PATCH 10/13] Remove main method from MonotonicIncreasingStack Removed the main method and related print statements. --- .../thealgorithms/stacks/MonotonicIncreasingStack.java | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index 3ee512ca7d5e..f4732f7d0208 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -42,16 +42,6 @@ public static int[] nextSmallerElement(int[] arr) { } return result; } - - public static void main(String[] args) { - int[] arr = {4, 5, 2, 10, 8}; - - int[] nextGreater = nextGreaterElement(arr); - int[] nextSmaller = nextSmallerElement(arr); - - System.out.println("Next Greater Element: " + Arrays.toString(nextGreater)); - System.out.println("Next Smaller Element: " + Arrays.toString(nextSmaller)); - } } /* Reference: https://www.geeksforgeeks.org/dsa/introduction-to-monotonic-stack-2/ */ From d8832e1b7db7ab914a9140331d46237643c7c4fb Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Fri, 3 Oct 2025 11:02:39 +0530 Subject: [PATCH 11/13] Remove unused import of Arrays in MonotonicIncreasingStack Removed unused import statement for Arrays. --- .../java/com/thealgorithms/stacks/MonotonicIncreasingStack.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index f4732f7d0208..151598dbbdd3 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -4,7 +4,6 @@ * in solving various problems including Stock Span, Trapping Rain Water */ -import java.util.Arrays; import java.util.Stack; public final class MonotonicIncreasingStack { From c3bc74c64b78a3238c94697c0b8a23aee9fda636 Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Wed, 8 Oct 2025 18:07:00 +0530 Subject: [PATCH 12/13] Implement test scenarios for MonotonicIncreasingStack Added main method and test scenarios for next greater and next smaller element functions. --- .../stacks/MonotonicIncreasingStack.java | 57 +++++++++++++++++-- 1 file changed, 52 insertions(+), 5 deletions(-) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index 151598dbbdd3..58d1b2732fec 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -1,7 +1,13 @@ -/* Contributor: Nayan Saraff +/** + * Contributor: Nayan Saraff * - * This Monotonic Increasing Stack is a popular algorithm which helps - * in solving various problems including Stock Span, Trapping Rain Water + * A Monotonic Increasing Stack is an algorithmic pattern used to solve + * problems such as Stock Span, Trapping Rain Water, and Next Greater Element. + * It maintains a stack where elements are in increasing order to efficiently + * find relationships between elements based on their relative values. + * + * Reference: + * https://www.geeksforgeeks.org/dsa/introduction-to-monotonic-stack-2/ */ import java.util.Stack; @@ -12,6 +18,15 @@ private MonotonicIncreasingStack() { throw new AssertionError("Cannot instantiate utility class"); } + /** + * Finds the next greater element for each element in the given array. + * + * For each element, it returns the nearest greater element to its right. + * If no such element exists, -1 is returned for that index. + * + * Time Complexity: O(n) + * Space Complexity: O(n) + */ public static int[] nextGreaterElement(int[] arr) { int n = arr.length; int[] result = new int[n]; @@ -27,6 +42,15 @@ public static int[] nextGreaterElement(int[] arr) { return result; } + /** + * Finds the next smaller element for each element in the given array. + * + * For each element, it returns the nearest smaller element to its right. + * If no such element exists, -1 is returned for that index. + * + * Time Complexity: O(n) + * Space Complexity: O(n) + */ public static int[] nextSmallerElement(int[] arr) { int n = arr.length; int[] result = new int[n]; @@ -41,6 +65,29 @@ public static int[] nextSmallerElement(int[] arr) { } return result; } -} -/* Reference: https://www.geeksforgeeks.org/dsa/introduction-to-monotonic-stack-2/ */ + // Test class included in the same file + public static void main(String[] args) { + testScenario(new int[]{2, 5, 1, 3, 4}); + testScenario(new int[]{1, 2, 3, 4, 5}); + testScenario(new int[]{5, 4, 3, 2, 1}); + } + + private static void testScenario(int[] arr) { + int[] nextGreater = nextGreaterElement(arr); + int[] nextSmaller = nextSmallerElement(arr); + + System.out.print("Array: "); + printArray(arr); + System.out.print("Next Greater: "); + printArray(nextGreater); + System.out.print("Next Smaller: "); + printArray(nextSmaller); + System.out.println("-----------------------------"); + } + + private static void printArray(int[] arr) { + for (int n : arr) System.out.print(n + " "); + System.out.println(); + } +} From 760330383d971e6a5726a337603cc8090781b6b1 Mon Sep 17 00:00:00 2001 From: NayanSaraff Date: Wed, 8 Oct 2025 18:13:46 +0530 Subject: [PATCH 13/13] Update MonotonicIncreasingStack.java --- .../stacks/MonotonicIncreasingStack.java | 132 +++++++++--------- 1 file changed, 67 insertions(+), 65 deletions(-) diff --git a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java index 58d1b2732fec..a22e6b42ae3b 100644 --- a/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java +++ b/src/test/java/com/thealgorithms/stacks/MonotonicIncreasingStack.java @@ -10,84 +10,86 @@ * https://www.geeksforgeeks.org/dsa/introduction-to-monotonic-stack-2/ */ +package com.thealgorithms.stacks; + import java.util.Stack; public final class MonotonicIncreasingStack { - private MonotonicIncreasingStack() { - throw new AssertionError("Cannot instantiate utility class"); - } + private MonotonicIncreasingStack() { + throw new AssertionError("Cannot instantiate utility class"); + } - /** - * Finds the next greater element for each element in the given array. - * - * For each element, it returns the nearest greater element to its right. - * If no such element exists, -1 is returned for that index. - * - * Time Complexity: O(n) - * Space Complexity: O(n) - */ - public static int[] nextGreaterElement(int[] arr) { - int n = arr.length; - int[] result = new int[n]; - Stack stack = new Stack<>(); + /** + * Finds the next greater element for each element in the given array. + * For each element, it returns the nearest greater element to its right. + * If no such element exists, -1 is returned for that index. + * + * Time Complexity: O(n) + * Space Complexity: O(n) + */ + public static int[] nextGreaterElement(int[] arr) { + int n = arr.length; + int[] result = new int[n]; + Stack stack = new Stack<>(); - for (int i = n - 1; i >= 0; i--) { - while (!stack.isEmpty() && arr[i] >= arr[stack.peek()]) { - stack.pop(); - } - result[i] = stack.isEmpty() ? -1 : arr[stack.peek()]; - stack.push(i); - } - return result; + for (int i = n - 1; i >= 0; i--) { + while (!stack.isEmpty() && arr[i] >= arr[stack.peek()]) { + stack.pop(); + } + result[i] = stack.isEmpty() ? -1 : arr[stack.peek()]; + stack.push(i); } + return result; + } - /** - * Finds the next smaller element for each element in the given array. - * - * For each element, it returns the nearest smaller element to its right. - * If no such element exists, -1 is returned for that index. - * - * Time Complexity: O(n) - * Space Complexity: O(n) - */ - public static int[] nextSmallerElement(int[] arr) { - int n = arr.length; - int[] result = new int[n]; - Stack stack = new Stack<>(); + /** + * Finds the next smaller element for each element in the given array. + * For each element, it returns the nearest smaller element to its right. + * If no such element exists, -1 is returned for that index. + * + * Time Complexity: O(n) + * Space Complexity: O(n) + */ + public static int[] nextSmallerElement(int[] arr) { + int n = arr.length; + int[] result = new int[n]; + Stack stack = new Stack<>(); - for (int i = n - 1; i >= 0; i--) { - while (!stack.isEmpty() && arr[i] <= arr[stack.peek()]) { - stack.pop(); - } - result[i] = stack.isEmpty() ? -1 : arr[stack.peek()]; - stack.push(i); - } - return result; + for (int i = n - 1; i >= 0; i--) { + while (!stack.isEmpty() && arr[i] <= arr[stack.peek()]) { + stack.pop(); + } + result[i] = stack.isEmpty() ? -1 : arr[stack.peek()]; + stack.push(i); } + return result; + } - // Test class included in the same file - public static void main(String[] args) { - testScenario(new int[]{2, 5, 1, 3, 4}); - testScenario(new int[]{1, 2, 3, 4, 5}); - testScenario(new int[]{5, 4, 3, 2, 1}); - } + // Test class included in the same file + public static void main(String[] args) { + testScenario(new int[]{2, 5, 1, 3, 4}); + testScenario(new int[]{1, 2, 3, 4, 5}); + testScenario(new int[]{5, 4, 3, 2, 1}); + } - private static void testScenario(int[] arr) { - int[] nextGreater = nextGreaterElement(arr); - int[] nextSmaller = nextSmallerElement(arr); + private static void testScenario(int[] arr) { + int[] nextGreater = nextGreaterElement(arr); + int[] nextSmaller = nextSmallerElement(arr); - System.out.print("Array: "); - printArray(arr); - System.out.print("Next Greater: "); - printArray(nextGreater); - System.out.print("Next Smaller: "); - printArray(nextSmaller); - System.out.println("-----------------------------"); - } + System.out.print("Array: "); + printArray(arr); + System.out.print("Next Greater: "); + printArray(nextGreater); + System.out.print("Next Smaller: "); + printArray(nextSmaller); + System.out.println("-----------------------------"); + } - private static void printArray(int[] arr) { - for (int n : arr) System.out.print(n + " "); - System.out.println(); + private static void printArray(int[] arr) { + for (int n : arr) { + System.out.print(n + " "); } + System.out.println(); + } }