Update stack_with_doubly_linked_list.py

Author: lighting9999

data_structures/stacks/stack_with_doubly_linked_list.py

@@ -1,22 +1,17 @@
-# A complete working Python program to demonstrate all
-# stack operations using a doubly linked list
-
+# Complete Python program demonstrating stack operations using a doubly linked list
 from __future__ import annotations
 
-from typing import Generic, TypeVar
-
-T = TypeVar("T")
-
-
-class Node(Generic[T]):
+class Node[T]:
+    """Node class for doubly linked list"""
     def __init__(self, data: T):
-        self.data = data  # Assign data
-        self.next: Node[T] | None = None  # Initialize next as null
-        self.prev: Node[T] | None = None  # Initialize prev as null
+        self.data = data  # Node data
+        self.next: Node[T] | None = None  # Reference to next node
+        self.prev: Node[T] | None = None  # Reference to previous node
 
-
-class Stack(Generic[T]):
+class Stack[T]:
     """
+    Stack implementation using doubly linked list
+    
     >>> stack = Stack()
     >>> stack.is_empty()
     True
@@ -42,89 +37,75 @@ class Stack(Generic[T]):
     """
 
     def __init__(self) -> None:
-        self.head: Node[T] | None = None
+        self.head: Node[T] | None = None  # Top of stack
 
     def push(self, data: T) -> None:
-        """add a Node to the stack"""
+        """Push element onto stack"""
         if self.head is None:
             self.head = Node(data)
         else:
             new_node = Node(data)
+            # Insert new node at head
             self.head.prev = new_node
             new_node.next = self.head
-            new_node.prev = None
             self.head = new_node
 
     def pop(self) -> T | None:
-        """pop the top element off the stack"""
+        """Pop element from top of stack"""
         if self.head is None:
             return None
-        else:
-            assert self.head is not None
-            temp = self.head.data
-            self.head = self.head.next
-            if self.head is not None:
-                self.head.prev = None
-            return temp
+            
+        # Remove and return head node data
+        temp = self.head.data
+        self.head = self.head.next
+        if self.head is not None:
+            self.head.prev = None  # Clear prev reference for new head
+        return temp
 
     def top(self) -> T | None:
-        """return the top element of the stack"""
+        """Peek at top element without removing"""
         return self.head.data if self.head is not None else None
 
     def __len__(self) -> int:
-        temp = self.head
+        """Return number of elements in stack"""
         count = 0
-        while temp is not None:
+        current = self.head
+        while current:
             count += 1
-            temp = temp.next
+            current = current.next
         return count
 
     def is_empty(self) -> bool:
+        """Check if stack is empty"""
         return self.head is None
 
     def print_stack(self) -> None:
+        """Print all stack elements"""
         print("stack elements are:")
-        temp = self.head
-        while temp is not None:
-            print(temp.data, end="->")
-            temp = temp.next
-
+        current = self.head
+        while current:
+            print(current.data, end="->")
+            current = current.next
 
-# Code execution starts here
+# Program entry point
 if __name__ == "__main__":
-    # Start with the empty stack
-    stack: Stack[int] = Stack()
+    stack: Stack[int] = Stack()  # Create integer stack
 
-    # Insert 4 at the beginning. So stack becomes 4->None
     print("Stack operations using Doubly LinkedList")
+    # Push elements onto stack
     stack.push(4)
-
-    # Insert 5 at the beginning. So stack becomes 4->5->None
     stack.push(5)
-
-    # Insert 6 at the beginning. So stack becomes 4->5->6->None
     stack.push(6)
-
-    # Insert 7 at the beginning. So stack becomes 4->5->6->7->None
     stack.push(7)
 
-    # Print the stack
-    stack.print_stack()
+    stack.print_stack()  # Print current stack
 
-    # Print the top element
-    print("\nTop element is ", stack.top())
+    print("\nTop element is", stack.top())  # Show top element
+    print("Size of stack is", len(stack))  # Show size
 
-    # Print the stack size
-    print("Size of the stack is ", len(stack))
-
-    # pop the top element
+    # Pop two elements
     stack.pop()
-
-    # pop the top element
     stack.pop()
 
-    # two elements have now been popped off
-    stack.print_stack()
-
-    # Print True if the stack is empty else False
-    print("\nstack is empty:", stack.is_empty())
+    stack.print_stack()  # Print modified stack
+    print("\nStack is empty:", stack.is_empty())  # Check emptiness