Fix conflicts

Author: lorduke22

src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java

@@ -1,58 +1,109 @@
 package com.thealgorithms.datastructures.stacks;
 
 /**
- * Implementation of a stack using nodes. Unlimited size, no arraylist.
+ * A stack implementation using linked nodes, supporting unlimited size without an ArrayList.
  *
+ * <p>Each node in the stack contains data of generic type {@code Item}, along with references
+ * to the next and previous nodes, supporting typical stack operations.
+ *
+ * <p>The stack follows a Last-In-First-Out (LIFO) order where elements added last are
+ * removed first. Supported operations include push, pop, and peek.
+ *
+ * @param <Item> the type of elements held in this stack
  */
 public class NodeStack<Item> {
 
-    private Item data;
-    private NodeStack<Item> previous;
-    private NodeStack<Item> head;
-    private int size = 0;
+    /**
+     * Node class representing each element in the stack.
+     */
+    private class Node {
+        Item data;
+        Node previous;
 
-    public NodeStack() {
+        Node(Item data) {
+            this.data = data;
+            this.previous = null;
+        }
     }
 
-    private NodeStack(Item item) {
-        this.data = item;
+    private Node head; // Top node in the stack
+    private int size; // Number of elements in the stack
+
+    /**
+     * Constructs an empty NodeStack.
+     */
+    public NodeStack() {
+        head = null;
+        size = 0;
     }
 
+    /**
+     * Pushes an item onto the stack.
+     *
+     * @param item the item to be pushed onto the stack
+     */
     public void push(Item item) {
-        NodeStack<Item> newNode = new NodeStack<>(item);
-
-        if (isEmpty()) {
-            head = newNode;
-        } else {
-            newNode.previous = head;
-            head = newNode;
-        }
+        Node newNode = new Node(item);
+        newNode.previous = head;
+        head = newNode;
         size++;
     }
 
+    /**
+     * Removes and returns the item at the top of the stack.
+     *
+     * @return the item at the top of the stack, or {@code null} if the stack is empty
+     * @throws IllegalStateException if the stack is empty
+     */
     public Item pop() {
         if (isEmpty()) {
-            throw new IllegalStateException("Stack is empty, cannot peek element");
+            throw new IllegalStateException("Cannot pop from an empty stack.");
         }
-
-        Item item = head.data;
+        Item data = head.data;
         head = head.previous;
         size--;
-        return item;
+        return data;
     }
 
+    /**
+     * Returns the item at the top of the stack without removing it.
+     *
+     * @return the item at the top of the stack, or {@code null} if the stack is empty
+     * @throws IllegalStateException if the stack is empty
+     */
     public Item peek() {
         if (isEmpty()) {
-            throw new IllegalStateException("Stack is empty, cannot peek element");
+            throw new IllegalStateException("Cannot peek from an empty stack.");
         }
         return head.data;
     }
 
+    /**
+     * Checks whether the stack is empty.
+     *
+     * @return {@code true} if the stack has no elements, {@code false} otherwise
+     */
     public boolean isEmpty() {
-        return size == 0;
+        return head == null;
     }
 
+    /**
+     * Returns the number of elements currently in the stack.
+     *
+     * @return the size of the stack
+     */
     public int size() {
         return size;
     }
+
+    /**
+     * Prints the contents of the stack from top to bottom.
+     */
+    public void print() {
+        Node current = head;
+        while (current != null) {
+            System.out.println(current.data);
+            current = current.previous;
+        }
+    }
 }

src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java

@@ -5,62 +5,81 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import java.io.ByteArrayOutputStream;
-import java.io.PrintStream;
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 class NodeStackTest {
 
-    private NodeStack<Integer> stack;
-    private final ByteArrayOutputStream outputStreamCaptor = new ByteArrayOutputStream();
+    @Test
+    void testPush() {
+        NodeStack<Integer> stack = new NodeStack<>();
+        stack.push(10);
+        stack.push(20);
+        assertEquals(20, stack.peek(), "Top element should be 20 after pushing 10 and 20.");
+    }
 
-    @BeforeEach
-    void setUp() {
-        stack = new NodeStack<>();
-        System.setOut(new PrintStream(outputStreamCaptor));
+    @Test
+    void testPop() {
+        NodeStack<String> stack = new NodeStack<>();
+        stack.push("First");
+        stack.push("Second");
+        assertEquals("Second", stack.pop(), "Pop should return 'Second', the last pushed element.");
+        assertEquals("First", stack.pop(), "Pop should return 'First' after 'Second' is removed.");
     }
 
     @Test
-    void testPushAndPeek() {
-        stack.push(3);
-        assertEquals(3, stack.peek(), "Peek should return the last pushed item");
-        stack.push(4);
-        stack.push(5);
-        assertEquals(5, stack.peek(), "Peek should return the last pushed item");
+    void testPopOnEmptyStack() {
+        NodeStack<Double> stack = new NodeStack<>();
+        assertThrows(IllegalStateException.class, stack::pop, "Popping an empty stack should throw IllegalStateException.");
     }
 
     @Test
-    void testPop() {
+    void testPeek() {
+        NodeStack<Integer> stack = new NodeStack<>();
         stack.push(5);
-        stack.push(7);
-        assertEquals(7, stack.pop(), "Pop should return the last pushed item");
-        assertEquals(5, stack.pop(), "Pop should return the next item in stack");
-        assertTrue(stack.isEmpty(), "Stack should be empty after popping all elements");
+        stack.push(15);
+        assertEquals(15, stack.peek(), "Peek should return 15, the top element.");
+        stack.pop();
+        assertEquals(5, stack.peek(), "Peek should return 5 after 15 is popped.");
     }
 
     @Test
-    void testIsEmpty() {
-        assertTrue(stack.isEmpty(), "New stack should be empty");
-        stack.push(1);
-        assertFalse(stack.isEmpty(), "Stack should not be empty after push");
+    void testPeekOnEmptyStack() {
+        NodeStack<String> stack = new NodeStack<>();
+        assertThrows(IllegalStateException.class, stack::peek, "Peeking an empty stack should throw IllegalStateException.");
     }
 
     @Test
-    void testSize() {
-        assertEquals(0, stack.size(), "New stack should have size 0");
-        stack.push(10);
-        stack.push(20);
-        assertEquals(2, stack.size(), "Stack size should be 2 after two pushes");
+    void testIsEmpty() {
+        NodeStack<Character> stack = new NodeStack<>();
+        assertTrue(stack.isEmpty(), "Newly initialized stack should be empty.");
+        stack.push('A');
+        assertFalse(stack.isEmpty(), "Stack should not be empty after a push operation.");
+        stack.pop();
+        assertTrue(stack.isEmpty(), "Stack should be empty after popping the only element.");
     }
 
     @Test
-    void testPopOnEmptyStack() {
-        assertThrows(IllegalStateException.class, () -> { stack.pop(); });
+    void testSize() {
+        NodeStack<Integer> stack = new NodeStack<>();
+        assertEquals(0, stack.size(), "Size of empty stack should be 0.");
+        stack.push(3);
+        stack.push(6);
+        assertEquals(2, stack.size(), "Size should be 2 after pushing two elements.");
+        stack.pop();
+        assertEquals(1, stack.size(), "Size should be 1 after popping one element.");
+        stack.pop();
+        assertEquals(0, stack.size(), "Size should be 0 after popping all elements.");
     }
 
     @Test
-    void testPeekOnEmptyStack() {
-        assertThrows(IllegalStateException.class, () -> { stack.peek(); });
+    void testPrint() {
+        NodeStack<Integer> stack = new NodeStack<>();
+        stack.push(1);
+        stack.push(2);
+        stack.push(3);
+
+        // Output verification would ideally be handled through a different means
+        // but you can print as a basic check to confirm method runs without errors.
+        stack.print();
     }
 }