From ca21a27946edb0ab5921af584d1b06803a307689 Mon Sep 17 00:00:00 2001
From: prashantpiyush1111 <Prashantpiyush1111@gmail.com>
Date: Tue, 14 Apr 2026 10:18:45 +0530
Subject: [PATCH 1/9] docs: add edge cases to JumpSearch documentation

---
 src/main/java/com/thealgorithms/searches/JumpSearch.java | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/searches/JumpSearch.java b/src/main/java/com/thealgorithms/searches/JumpSearch.java
index cbc494c8c16a..a069156355e3 100644
--- a/src/main/java/com/thealgorithms/searches/JumpSearch.java
+++ b/src/main/java/com/thealgorithms/searches/JumpSearch.java
@@ -34,7 +34,14 @@
  *
  * <p>
  * <b>Space Complexity:</b> O(1) - only uses a constant amount of extra space
- *
+ * 
+ * <p>
+ * <b>Edge Cases:</b>
+ * <ul>
+ *   <li>Empty array → returns -1</li>
+ *   <li>Element not present → returns -1</li>
+ *   <li>Single element array</li>
+ * </ul>
  * <p>
  * <b>Note:</b> Jump Search requires a sorted array. For unsorted arrays, use Linear Search.
  * Compared to Linear Search (O(n)), Jump Search is faster for large arrays.

From 4c7ac35a155f5a32b401c880dcdbecdf7f68e6f8 Mon Sep 17 00:00:00 2001
From: prashantpiyush1111 <Prashantpiyush1111@gmail.com>
Date: Tue, 14 Apr 2026 13:45:39 +0530
Subject: [PATCH 2/9] fix: remove trailing whitespace (checkstyle)

---
 src/main/java/com/thealgorithms/searches/JumpSearch.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/searches/JumpSearch.java b/src/main/java/com/thealgorithms/searches/JumpSearch.java
index a069156355e3..5074aa7845c8 100644
--- a/src/main/java/com/thealgorithms/searches/JumpSearch.java
+++ b/src/main/java/com/thealgorithms/searches/JumpSearch.java
@@ -34,7 +34,7 @@
  *
  * <p>
  * <b>Space Complexity:</b> O(1) - only uses a constant amount of extra space
- * 
+ *
  * <p>
  * <b>Edge Cases:</b>
  * <ul>

From 56a087d5d7cc28aa42f459dee613eb4bf5fa7c55 Mon Sep 17 00:00:00 2001
From: prashantpiyush1111 <Prashantpiyush1111@gmail.com>
Date: Tue, 14 Apr 2026 23:51:10 +0530
Subject: [PATCH 3/9] docs: add simple example and beginner-friendly
 explanation to JumpSearch

---
 .../java/com/thealgorithms/searches/JumpSearch.java   | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/main/java/com/thealgorithms/searches/JumpSearch.java b/src/main/java/com/thealgorithms/searches/JumpSearch.java
index 5074aa7845c8..e93738f1cb28 100644
--- a/src/main/java/com/thealgorithms/searches/JumpSearch.java
+++ b/src/main/java/com/thealgorithms/searches/JumpSearch.java
@@ -27,6 +27,17 @@
  * Result: Index = 4
  *
  * <p>
+ * <b>Example (Simple):</b><br>
+ * Input: arr = [2, 4, 6, 8, 10], key = 8<br>
+ * Output: 3
+ *
+ * <p>
+ * <b>Explanation (Easy):</b><br>
+ * Instead of checking every element one by one, Jump Search skips elements
+ * by jumping ahead fixed steps (√n). Once it finds a range where the element
+ * might exist, it performs a linear search in that smaller block.
+ *
+ * <p>
  * <b>Time Complexity:</b><br>
  * - Best-case: O(1) - element found at first position<br>
  * - Average: O(√n) - optimal block size reduces jumps<br>

From 41020e5a2a29cc15e7d677148304c6a4512a1d0c Mon Sep 17 00:00:00 2001
From: prashantpiyush1111 <Prashantpiyush1111@gmail.com>
Date: Wed, 15 Apr 2026 07:43:32 +0530
Subject: [PATCH 4/9] feat: add StackUsingLinkedList implementation with test
 cases

---
 .../stacks/StackUsingLinkedList.java          | 70 ++++++++++++++++++
 .../stacks/StackUsingLinkedListTest.java      | 71 +++++++++++++++++++
 2 files changed, 141 insertions(+)
 create mode 100644 src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
 create mode 100644 src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java

diff --git a/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java b/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
new file mode 100644
index 000000000000..da5edb5d18b3
--- /dev/null
+++ b/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
@@ -0,0 +1,70 @@
+package com.thealgorithms.stacks;
+
+/**
+ * A class that implements a Stack using a singly linked list.
+ * Supports basic operations like push, pop, peek, and isEmpty.
+ *
+ * Reference: https://www.geeksforgeeks.org/stack-using-linked-list/
+ */
+public class StackUsingLinkedList {
+
+    /**
+     * Node class representing each element in the stack
+     */
+    private static class Node {
+        int data;
+        Node next;
+
+        Node(int data) {
+            this.data = data;
+        }
+    }
+
+    private Node top;
+
+    /**
+     * Push an element onto the stack
+     *
+     * @param value the value to push
+     */
+    public void push(int value) {
+        Node newNode = new Node(value);
+        newNode.next = top;
+        top = newNode;
+    }
+
+    /**
+     * Remove and return the top element of the stack
+     *
+     * @return top element
+     */
+    public int pop() {
+        if (top == null) {
+            throw new RuntimeException("Stack is empty");
+        }
+        int value = top.data;
+        top = top.next;
+        return value;
+    }
+
+    /**
+     * Return the top element without removing it
+     *
+     * @return top element
+     */
+    public int peek() {
+        if (top == null) {
+            throw new RuntimeException("Stack is empty");
+        }
+        return top.data;
+    }
+
+    /**
+     * Check if the stack is empty
+     *
+     * @return true if empty, false otherwise
+     */
+    public boolean isEmpty() {
+        return top == null;
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java b/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
new file mode 100644
index 000000000000..23b85a19c1b6
--- /dev/null
+++ b/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
@@ -0,0 +1,71 @@
+package com.thealgorithms.stacks;
+
+import static org.junit.jupiter.api.Assertions.*;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for StackUsingLinkedList.
+ *
+ * This class contains unit tests to verify the correctness
+ * of stack operations such as push, pop, peek, and isEmpty.
+ *
+ * Reference: https://www.geeksforgeeks.org/stack-using-linked-list/
+ */
+class StackUsingLinkedListTest {
+
+    /**
+     * Test push and pop operations
+     */
+    @Test
+    void testPushAndPop() {
+        StackUsingLinkedList stack = new StackUsingLinkedList();
+        stack.push(10);
+        stack.push(20);
+
+        assertEquals(20, stack.pop());
+        assertEquals(10, stack.pop());
+    }
+
+    /**
+     * Test peek operation
+     */
+    @Test
+    void testPeek() {
+        StackUsingLinkedList stack = new StackUsingLinkedList();
+        stack.push(5);
+
+        assertEquals(5, stack.peek());
+    }
+
+    /**
+     * Test isEmpty method
+     */
+    @Test
+    void testIsEmpty() {
+        StackUsingLinkedList stack = new StackUsingLinkedList();
+
+        assertTrue(stack.isEmpty());
+        stack.push(1);
+        assertFalse(stack.isEmpty());
+    }
+
+    /**
+     * Test pop on empty stack (edge case)
+     */
+    @Test
+    void testPopOnEmptyStack() {
+        StackUsingLinkedList stack = new StackUsingLinkedList();
+
+        assertThrows(RuntimeException.class, stack::pop);
+    }
+
+    /**
+     * Test peek on empty stack (edge case)
+     */
+    @Test
+    void testPeekOnEmptyStack() {
+        StackUsingLinkedList stack = new StackUsingLinkedList();
+
+        assertThrows(RuntimeException.class, stack::peek);
+    }
+}
\ No newline at end of file

From db4e0c3944b228f5495fb24fb9e95e00d53ffc72 Mon Sep 17 00:00:00 2001
From: prashantpiyush1111 <Prashantpiyush1111@gmail.com>
Date: Wed, 15 Apr 2026 07:45:57 +0530
Subject: [PATCH 5/9] style: apply clang-format to fix formatting issues

---
 .../stacks/StackUsingLinkedList.java          | 110 +++++++++---------
 .../stacks/StackUsingLinkedListTest.java      |  96 +++++++--------
 2 files changed, 103 insertions(+), 103 deletions(-)

diff --git a/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java b/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
index da5edb5d18b3..0bd81a7ea96f 100644
--- a/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
+++ b/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
@@ -1,70 +1,70 @@
 package com.thealgorithms.stacks;
 
 /**
- * A class that implements a Stack using a singly linked list.
- * Supports basic operations like push, pop, peek, and isEmpty.
+ * A class that implements a Stack using a singly linked list. Supports basic
+ * operations like push, pop, peek, and isEmpty.
  *
  * Reference: https://www.geeksforgeeks.org/stack-using-linked-list/
  */
 public class StackUsingLinkedList {
 
-    /**
-     * Node class representing each element in the stack
-     */
-    private static class Node {
-        int data;
-        Node next;
+	/**
+	 * Node class representing each element in the stack
+	 */
+	private static class Node {
+		int data;
+		Node next;
 
-        Node(int data) {
-            this.data = data;
-        }
-    }
+		Node(int data) {
+			this.data = data;
+		}
+	}
 
-    private Node top;
+	private Node top;
 
-    /**
-     * Push an element onto the stack
-     *
-     * @param value the value to push
-     */
-    public void push(int value) {
-        Node newNode = new Node(value);
-        newNode.next = top;
-        top = newNode;
-    }
+	/**
+	 * Push an element onto the stack
+	 *
+	 * @param value the value to push
+	 */
+	public void push(int value) {
+		Node newNode = new Node(value);
+		newNode.next = top;
+		top = newNode;
+	}
 
-    /**
-     * Remove and return the top element of the stack
-     *
-     * @return top element
-     */
-    public int pop() {
-        if (top == null) {
-            throw new RuntimeException("Stack is empty");
-        }
-        int value = top.data;
-        top = top.next;
-        return value;
-    }
+	/**
+	 * Remove and return the top element of the stack
+	 *
+	 * @return top element
+	 */
+	public int pop() {
+		if (top == null) {
+			throw new RuntimeException("Stack is empty");
+		}
+		int value = top.data;
+		top = top.next;
+		return value;
+	}
 
-    /**
-     * Return the top element without removing it
-     *
-     * @return top element
-     */
-    public int peek() {
-        if (top == null) {
-            throw new RuntimeException("Stack is empty");
-        }
-        return top.data;
-    }
+	/**
+	 * Return the top element without removing it
+	 *
+	 * @return top element
+	 */
+	public int peek() {
+		if (top == null) {
+			throw new RuntimeException("Stack is empty");
+		}
+		return top.data;
+	}
 
-    /**
-     * Check if the stack is empty
-     *
-     * @return true if empty, false otherwise
-     */
-    public boolean isEmpty() {
-        return top == null;
-    }
+	/**
+	 * Check if the stack is empty
+	 *
+	 * @return true if empty, false otherwise
+	 */
+	public boolean isEmpty() {
+		return top == null;
+	}
 }
\ No newline at end of file
diff --git a/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java b/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
index 23b85a19c1b6..86032580ecc5 100644
--- a/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
+++ b/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
@@ -6,66 +6,66 @@
 /**
  * Test class for StackUsingLinkedList.
  *
- * This class contains unit tests to verify the correctness
- * of stack operations such as push, pop, peek, and isEmpty.
+ * This class contains unit tests to verify the correctness of stack operations
+ * such as push, pop, peek, and isEmpty.
  *
  * Reference: https://www.geeksforgeeks.org/stack-using-linked-list/
  */
 class StackUsingLinkedListTest {
 
-    /**
-     * Test push and pop operations
-     */
-    @Test
-    void testPushAndPop() {
-        StackUsingLinkedList stack = new StackUsingLinkedList();
-        stack.push(10);
-        stack.push(20);
+	/**
+	 * Test push and pop operations
+	 */
+	@Test
+	void testPushAndPop() {
+		StackUsingLinkedList stack = new StackUsingLinkedList();
+		stack.push(10);
+		stack.push(20);
 
-        assertEquals(20, stack.pop());
-        assertEquals(10, stack.pop());
-    }
+		assertEquals(20, stack.pop());
+		assertEquals(10, stack.pop());
+	}
 
-    /**
-     * Test peek operation
-     */
-    @Test
-    void testPeek() {
-        StackUsingLinkedList stack = new StackUsingLinkedList();
-        stack.push(5);
+	/**
+	 * Test peek operation
+	 */
+	@Test
+	void testPeek() {
+		StackUsingLinkedList stack = new StackUsingLinkedList();
+		stack.push(5);
 
-        assertEquals(5, stack.peek());
-    }
+		assertEquals(5, stack.peek());
+	}
 
-    /**
-     * Test isEmpty method
-     */
-    @Test
-    void testIsEmpty() {
-        StackUsingLinkedList stack = new StackUsingLinkedList();
+	/**
+	 * Test isEmpty method
+	 */
+	@Test
+	void testIsEmpty() {
+		StackUsingLinkedList stack = new StackUsingLinkedList();
 
-        assertTrue(stack.isEmpty());
-        stack.push(1);
-        assertFalse(stack.isEmpty());
-    }
+		assertTrue(stack.isEmpty());
+		stack.push(1);
+		assertFalse(stack.isEmpty());
+	}
 
-    /**
-     * Test pop on empty stack (edge case)
-     */
-    @Test
-    void testPopOnEmptyStack() {
-        StackUsingLinkedList stack = new StackUsingLinkedList();
+	/**
+	 * Test pop on empty stack (edge case)
+	 */
+	@Test
+	void testPopOnEmptyStack() {
+		StackUsingLinkedList stack = new StackUsingLinkedList();
 
-        assertThrows(RuntimeException.class, stack::pop);
-    }
+		assertThrows(RuntimeException.class, stack::pop);
+	}
 
-    /**
-     * Test peek on empty stack (edge case)
-     */
-    @Test
-    void testPeekOnEmptyStack() {
-        StackUsingLinkedList stack = new StackUsingLinkedList();
+	/**
+	 * Test peek on empty stack (edge case)
+	 */
+	@Test
+	void testPeekOnEmptyStack() {
+		StackUsingLinkedList stack = new StackUsingLinkedList();
 
-        assertThrows(RuntimeException.class, stack::peek);
-    }
+		assertThrows(RuntimeException.class, stack::peek);
+	}
 }
\ No newline at end of file

From 43553e1b041cbccaa156c18aa19dfb988eacbb26 Mon Sep 17 00:00:00 2001
From: prashantpiyush1111 <Prashantpiyush1111@gmail.com>
Date: Wed, 15 Apr 2026 07:52:36 +0530
Subject: [PATCH 6/9] style: fix checkstyle issues (newline and imports)

---
 .../com/thealgorithms/stacks/StackUsingLinkedListTest.java | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java b/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
index 86032580ecc5..463f8ccd351e 100644
--- a/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
+++ b/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
@@ -1,6 +1,9 @@
 package com.thealgorithms.stacks;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -68,4 +71,4 @@ void testPeekOnEmptyStack() {
 
 		assertThrows(RuntimeException.class, stack::peek);
 	}
-}
\ No newline at end of file
+}

From bedd1cea3bca69b9b0e8ec24821c7d13971b2bd1 Mon Sep 17 00:00:00 2001
From: prashantpiyush1111 <Prashantpiyush1111@gmail.com>
Date: Wed, 15 Apr 2026 07:55:23 +0530
Subject: [PATCH 7/9] style: fix newline at end of StackUsingLinkedList

---
 .../java/com/thealgorithms/stacks/StackUsingLinkedList.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java b/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
index 0bd81a7ea96f..f3714ddc7662 100644
--- a/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
+++ b/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
@@ -67,4 +67,4 @@ public int peek() {
 	public boolean isEmpty() {
 		return top == null;
 	}
-}
\ No newline at end of file
+}

From ca2cdfca83f4f674c1009a673312d98f4f105f68 Mon Sep 17 00:00:00 2001
From: prashantpiyush1111 <Prashantpiyush1111@gmail.com>
Date: Wed, 15 Apr 2026 07:58:55 +0530
Subject: [PATCH 8/9] style: fix formatting to satisfy clang-format and
 checkstyle

---
 .../stacks/StackUsingLinkedList.java          | 110 +++++++++---------
 .../stacks/StackUsingLinkedListTest.java      |  99 ++++++++--------
 2 files changed, 105 insertions(+), 104 deletions(-)

diff --git a/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java b/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
index f3714ddc7662..88197231795c 100644
--- a/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
+++ b/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
@@ -1,70 +1,70 @@
 package com.thealgorithms.stacks;
 
 /**
- * A class that implements a Stack using a singly linked list. Supports basic
- * operations like push, pop, peek, and isEmpty.
+ * A class that implements a Stack using a singly linked list.
+ * Supports basic operations like push, pop, peek, and isEmpty.
  *
  * Reference: https://www.geeksforgeeks.org/stack-using-linked-list/
  */
 public class StackUsingLinkedList {
 
-	/**
-	 * Node class representing each element in the stack
-	 */
-	private static class Node {
-		int data;
-		Node next;
+    /**
+     * Node class representing each element in the stack
+     */
+    private static class Node {
+        int data;
+        Node next;
 
-		Node(int data) {
-			this.data = data;
-		}
-	}
+        Node(int data) {
+            this.data = data;
+        }
+    }
 
-	private Node top;
+    private Node top;
 
-	/**
-	 * Push an element onto the stack
-	 *
-	 * @param value the value to push
-	 */
-	public void push(int value) {
-		Node newNode = new Node(value);
-		newNode.next = top;
-		top = newNode;
-	}
+    /**
+     * Push an element onto the stack
+     *
+     * @param value the value to push
+     */
+    public void push(int value) {
+        Node newNode = new Node(value);
+        newNode.next = top;
+        top = newNode;
+    }
 
-	/**
-	 * Remove and return the top element of the stack
-	 *
-	 * @return top element
-	 */
-	public int pop() {
-		if (top == null) {
-			throw new RuntimeException("Stack is empty");
-		}
-		int value = top.data;
-		top = top.next;
-		return value;
-	}
+    /**
+     * Remove and return the top element of the stack
+     *
+     * @return top element
+     */
+    public int pop() {
+        if (top == null) {
+            throw new RuntimeException("Stack is empty");
+        }
+        int value = top.data;
+        top = top.next;
+        return value;
+    }
 
-	/**
-	 * Return the top element without removing it
-	 *
-	 * @return top element
-	 */
-	public int peek() {
-		if (top == null) {
-			throw new RuntimeException("Stack is empty");
-		}
-		return top.data;
-	}
+    /**
+     * Return the top element without removing it
+     *
+     * @return top element
+     */
+    public int peek() {
+        if (top == null) {
+            throw new RuntimeException("Stack is empty");
+        }
+        return top.data;
+    }
 
-	/**
-	 * Check if the stack is empty
-	 *
-	 * @return true if empty, false otherwise
-	 */
-	public boolean isEmpty() {
-		return top == null;
-	}
+    /**
+     * Check if the stack is empty
+     *
+     * @return true if empty, false otherwise
+     */
+    public boolean isEmpty() {
+        return top == null;
+    }
 }
diff --git a/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java b/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
index 463f8ccd351e..c06604fa95fd 100644
--- a/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
+++ b/src/test/java/com/thealgorithms/stacks/StackUsingLinkedListTest.java
@@ -1,74 +1,75 @@
 package com.thealgorithms.stacks;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.junit.jupiter.api.Assertions.assertFalse;
+
 import org.junit.jupiter.api.Test;
 
 /**
  * Test class for StackUsingLinkedList.
  *
- * This class contains unit tests to verify the correctness of stack operations
- * such as push, pop, peek, and isEmpty.
+ * This class contains unit tests to verify the correctness
+ * of stack operations such as push, pop, peek, and isEmpty.
  *
  * Reference: https://www.geeksforgeeks.org/stack-using-linked-list/
  */
 class StackUsingLinkedListTest {
 
-	/**
-	 * Test push and pop operations
-	 */
-	@Test
-	void testPushAndPop() {
-		StackUsingLinkedList stack = new StackUsingLinkedList();
-		stack.push(10);
-		stack.push(20);
+    /**
+     * Test push and pop operations
+     */
+    @Test
+    void testPushAndPop() {
+        StackUsingLinkedList stack = new StackUsingLinkedList();
+        stack.push(10);
+        stack.push(20);
 
-		assertEquals(20, stack.pop());
-		assertEquals(10, stack.pop());
-	}
+        assertEquals(20, stack.pop());
+        assertEquals(10, stack.pop());
+    }
 
-	/**
-	 * Test peek operation
-	 */
-	@Test
-	void testPeek() {
-		StackUsingLinkedList stack = new StackUsingLinkedList();
-		stack.push(5);
+    /**
+     * Test peek operation
+     */
+    @Test
+    void testPeek() {
+        StackUsingLinkedList stack = new StackUsingLinkedList();
+        stack.push(5);
 
-		assertEquals(5, stack.peek());
-	}
+        assertEquals(5, stack.peek());
+    }
 
-	/**
-	 * Test isEmpty method
-	 */
-	@Test
-	void testIsEmpty() {
-		StackUsingLinkedList stack = new StackUsingLinkedList();
+    /**
+     * Test isEmpty method
+     */
+    @Test
+    void testIsEmpty() {
+        StackUsingLinkedList stack = new StackUsingLinkedList();
 
-		assertTrue(stack.isEmpty());
-		stack.push(1);
-		assertFalse(stack.isEmpty());
-	}
+        assertTrue(stack.isEmpty());
+        stack.push(1);
+        assertFalse(stack.isEmpty());
+    }
 
-	/**
-	 * Test pop on empty stack (edge case)
-	 */
-	@Test
-	void testPopOnEmptyStack() {
-		StackUsingLinkedList stack = new StackUsingLinkedList();
+    /**
+     * Test pop on empty stack (edge case)
+     */
+    @Test
+    void testPopOnEmptyStack() {
+        StackUsingLinkedList stack = new StackUsingLinkedList();
 
-		assertThrows(RuntimeException.class, stack::pop);
-	}
+        assertThrows(RuntimeException.class, stack::pop);
+    }
 
-	/**
-	 * Test peek on empty stack (edge case)
-	 */
-	@Test
-	void testPeekOnEmptyStack() {
-		StackUsingLinkedList stack = new StackUsingLinkedList();
+    /**
+     * Test peek on empty stack (edge case)
+     */
+    @Test
+    void testPeekOnEmptyStack() {
+        StackUsingLinkedList stack = new StackUsingLinkedList();
 
-		assertThrows(RuntimeException.class, stack::peek);
-	}
+        assertThrows(RuntimeException.class, stack::peek);
+    }
 }

From f330d390773ab21277554687d3541875c359e5f9 Mon Sep 17 00:00:00 2001
From: prashantpiyush1111 <Prashantpiyush1111@gmail.com>
Date: Wed, 15 Apr 2026 08:17:58 +0530
Subject: [PATCH 9/9] * This implementation uses a simple Node-based structure.

---
 .../java/com/thealgorithms/stacks/StackUsingLinkedList.java     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java b/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
index 88197231795c..daec1748735f 100644
--- a/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
+++ b/src/main/java/com/thealgorithms/stacks/StackUsingLinkedList.java
@@ -48,7 +48,7 @@ public int pop() {
     }
 
     /**
-     * Return the top element without removing it
+     * Return the top element without removing
      *
      * @return top element
      */