diff --git a/src/main/java/com/thealgorithms/datastructures/stacks/NearestElement.java b/src/main/java/com/thealgorithms/datastructures/stacks/NearestElement.java
new file mode 100644
index 000000000000..465e13fccbe7
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/stacks/NearestElement.java
@@ -0,0 +1,104 @@
+package datastructures.stacks;
+import java.util.Arrays;
+import java.util.Stack;
+
+/**
+ * NearestElement four classic stack based algorithms:
+ *Implemented methods:
+ * nearestGreaterToRight(int[] arr)  - for each index i, first element to the right  arr[i] or -1
+ * nearestGreaterToLeft(int[] arr)   - for each index i, first element to the left arr[i] or -1
+ * nearestSmallerToRight(int[] arr)  - for each index i, first element to the right arr[i] or -1
+ * nearestSmallerToLeft(int[] arr)   - for each index i, first element to the left arr[i] or -1
+ * All methods run in O(n) time and O(n) extra space (stack + output).
+ * Usage: Each method returns an int[] of the same length as input. If no nearest element satisfies the condition, -1 is used at that index.
+ */
+public class NearestElement {
+    /**
+     * For each element, finds the nearest greater element to its right.
+     * Example: [4, 5, 2, 25] -> [5, 25, 25, -1]
+     * Time: O(n), Space: O(n)
+     */
+    public static int[] nearestGreaterToRight(int[] arr) {
+        int n = arr.length;
+        int[] res = new int[n];
+        Arrays.fill(res, -1);
+        Stack<Integer> st = new Stack<>(); // it holds indices
+
+        // traverse left to right, but we pop while current > stack top
+        for (int i = 0; i < n; i++) {
+            while (!st.isEmpty() && arr[i] > arr[st.peek()]) {
+                res[st.pop()] = arr[i];
+            }
+            st.push(i);
+        }
+        return res;
+    }
+
+    /**
+     * For each element, finds the nearest greater element to its left.
+     * Example: [4, 5, 2, 25] -> [-1, -1, 5, -1]
+     * Time: O(n), Space: O(n)
+     */
+    public static int[] nearestGreaterToLeft(int[] arr) {
+        int n = arr.length;
+        int[] res = new int[n];
+        Arrays.fill(res, -1);
+        Stack<Integer> st = new Stack<>(); 
+        for (int i = 0; i < n; i++) {
+            while (!st.isEmpty() && arr[st.peek()] <= arr[i]) {
+                st.pop();
+            }
+            if (!st.isEmpty()) res[i] = arr[st.peek()];
+            st.push(i);
+        }
+        return res;
+    }
+
+    /**
+     * For each element, finds the nearest smaller element to its right.
+     * Example: [4, 5, 2, 25] -> [2, 2, -1, -1]
+     * Time: O(n), Space: O(n)
+     */
+    public static int[] nearestSmallerToRight(int[] arr) {
+        int n = arr.length;
+        int[] res = new int[n];
+        Arrays.fill(res, -1);
+        Stack<Integer> st = new Stack<>(); 
+        for (int i = 0; i < n; i++) {
+            while (!st.isEmpty() && arr[i] < arr[st.peek()]) {
+                res[st.pop()] = arr[i];
+            }
+            st.push(i);
+        }
+        return res;
+    }
+
+    /**
+     * For each element, finds the nearest smaller element to its left.
+     * Example: [4, 5, 2, 25] -> [-1, 4, -1, 2]
+     * Time: O(n), Space: O(n)
+     */
+    public static int[] nearestSmallerToLeft(int[] arr) {
+        int n = arr.length;
+        int[] res = new int[n];
+        Arrays.fill(res, -1);
+        Stack<Integer> st = new Stack<>(); // holds indices
+        for (int i = 0; i < n; i++) {
+            while (!st.isEmpty() && arr[st.peek()] >= arr[i]) {
+                st.pop();
+            }
+            if (!st.isEmpty()) res[i] = arr[st.peek()];
+            st.push(i);
+        }
+        return res;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {4, 5, 2, 25, 1, 7};
+        System.out.println("Input: " + Arrays.toString(arr));
+        System.out.println("Nearest Greater to Right: " + Arrays.toString(nearestGreaterToRight(arr)));
+        System.out.println("Nearest Greater to Left:  " + Arrays.toString(nearestGreaterToLeft(arr)));
+        System.out.println("Nearest Smaller to Right: " + Arrays.toString(nearestSmallerToRight(arr)));
+        System.out.println("Nearest Smaller to Left:  " + Arrays.toString(nearestSmallerToLeft(arr)));
+    }
+}