linked_list.py

# ============================================================
# Building a Linked List - Section by Section Demo
# Covers:
# 1. Linked List vs Array
# 2. Adding Nodes to a Linked List
# 3. Removing Nodes from a Linked List
# 4. Searching for a Node in a Linked List
# 5. Traversing a Linked List
# 6. Inserting a Node at a Specific Position
# 7. Deleting a Node at a Specific Position
# 8. Updating a Node at a Specific Position
# 9. Sorting a Linked List
# ============================================================

import time

# ============================================================
# SECTION 1: LINKED LIST VS ARRAY
# ============================================================

def section1_linked_list_vs_array():
   
    print("Array:    [10][20][30][40]")
    print("LL:       [10]->[20]->[30]->[40]->None")
    time.sleep(1.5)
    
    print("\n✅ SECTION 1 COMPLETE!")
    time.sleep(1)

# ============================================================
# SECTION 2: ADDING NODES TO A LINKED LIST
# ============================================================

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None
        self.size = 0
    
    def visualize(self):
        if self.head is None:
            print("Empty: []")
            return
        current = self.head
        while current:
            print(f"[{current.data}]", end=" -> ")
            current = current.next
        print("None")

def section2_adding_nodes():
    print("=" * 50)
    print("🔗 SECTION 2: ADDING NODES")
    print("=" * 50)
    
    ll = LinkedList()
    print("Created empty list")
    ll.visualize()
    time.sleep(1)
    
    print("\n➕ INSERT AT BEGINNING:")
    print("Adding 10...")
    time.sleep(0.8)
    
    new_node = Node(10)
    new_node.next = ll.head
    ll.head = new_node
    ll.size += 1
    
    print("Step 1: Create node [10]")
    time.sleep(0.8)
    print("Step 2: Point to head")
    time.sleep(0.8)
    print("Step 3: Update head")
    time.sleep(0.8)
    
    ll.visualize()
    time.sleep(1)
    
    print("\nAdding 20 at beginning...")
    time.sleep(0.8)
    
    new_node2 = Node(20)
    new_node2.next = ll.head
    ll.head = new_node2
    ll.size += 1
    
    ll.visualize()
    time.sleep(1)
    
    print("\n➕ INSERT AT END:")
    print("Adding 30 at end...")
    time.sleep(0.8)
    
    new_node3 = Node(30)
    if ll.head is None:
        ll.head = new_node3
    else:
        current = ll.head
        while current.next:
            current = current.next
        current.next = new_node3
    ll.size += 1
    
    print("Step 1: Create node [30]")
    time.sleep(0.8)
    print("Step 2: Find last node")
    time.sleep(0.8)
    print("Step 3: Link to new node")
    time.sleep(0.8)
    
    ll.visualize()
    time.sleep(1)
    
    print("\n✅ SECTION 2 COMPLETE!")
    time.sleep(1)

# ============================================================
# SECTION 3: REMOVING NODES FROM A LINKED LIST
# ============================================================

def section3_removing_nodes():
    print("=" * 50)
    print("🗑️ SECTION 3: REMOVING NODES")
    print("=" * 50)
    
    # Setup test data
    ll = LinkedList()
    values = [10, 20, 30, 40]
    for value in values:
        new_node = Node(value)
        if ll.head is None:
            ll.head = new_node
        else:
            current = ll.head
            while current.next:
                current = current.next
            current.next = new_node
        ll.size += 1
    
    print("Starting with:")
    ll.visualize()
    time.sleep(1)
    
    print("\n🗑️ DELETE FROM BEGINNING:")
    print("Deleting first node...")
    time.sleep(0.8)
    
    if ll.head:
        deleted = ll.head.data
        ll.head = ll.head.next
        ll.size -= 1
        print(f"Deleted [{deleted}]")
        time.sleep(0.8)
    
    ll.visualize()
    time.sleep(1)
    
    print("\n🗑️ DELETE FROM END:")
    print("Deleting last node...")
    time.sleep(0.8)
    
    if ll.head and ll.head.next:
        current = ll.head
        while current.next.next:
            current = current.next
        deleted = current.next.data
        current.next = None
        ll.size -= 1
        print(f"Deleted [{deleted}]")
        time.sleep(0.8)
    elif ll.head:
        deleted = ll.head.data
        ll.head = None
        ll.size -= 1
        print(f"Deleted [{deleted}]")
        time.sleep(0.8)
    
    ll.visualize()
    time.sleep(1)
    
    print("\n✅ SECTION 3 COMPLETE!")
    time.sleep(1)

# ============================================================
# SECTION 4: SEARCHING FOR A NODE
# ============================================================

def section4_searching():
    print("=" * 50)
    print("🔍 SECTION 4: SEARCHING")
    print("=" * 50)
    
    # Setup test data
    ll = LinkedList()
    values = [10, 20, 30, 40, 50]
    for value in values:
        new_node = Node(value)
        if ll.head is None:
            ll.head = new_node
        else:
            current = ll.head
            while current.next:
                current = current.next
            current.next = new_node
        ll.size += 1
    
    print("Searching in:")
    ll.visualize()
    time.sleep(1)
    
    target = 30
    print(f"\n🔍 SEARCHING FOR {target}:")
    time.sleep(0.8)
    
    current = ll.head
    position = 0
    
    while current:
        print(f"Checking position {position}: [{current.data}]", end="")
        time.sleep(0.6)
        
        if current.data == target:
            print(" ✓ FOUND!")
            print(f"Found {target} at position {position}")
            break
        else:
            print(" ✗")
        
        current = current.next
        position += 1
    else:
        print(f"\n{target} not found")
    
    time.sleep(1)
    print("\n✅ SECTION 4 COMPLETE!")
    time.sleep(1)

# ============================================================
# SECTION 5: TRAVERSING A LINKED LIST
# ============================================================

def section5_traversing():
    print("=" * 50)
    print("🚶 SECTION 5: TRAVERSING")
    print("=" * 50)
    
    # Setup test data
    ll = LinkedList()
    values = [10, 20, 30, 40]
    for value in values:
        new_node = Node(value)
        if ll.head is None:
            ll.head = new_node
        else:
            current = ll.head
            while current.next:
                current = current.next
            current.next = new_node
        ll.size += 1
    
    print("Traversing:")
    ll.visualize()
    time.sleep(1)
    
    print("\n🚶 STEP-BY-STEP TRAVERSAL:")
    time.sleep(0.8)
    
    current = ll.head
    position = 0
    
    while current:
        print(f"Position {position}: [{current.data}]", end="")
        time.sleep(0.6)
        
        if current.next:
            print(" -> next")
        else:
            print(" -> None (end)")
        
        current = current.next
        position += 1
    
    time.sleep(1)
    print("\n✅ SECTION 5 COMPLETE!")
    time.sleep(1)

# ============================================================
# SECTION 6: INSERTING AT SPECIFIC POSITION
# ============================================================

def section6_insert_at_position():
    print("=" * 50)
    print("📍 SECTION 6: INSERT AT POSITION")
    print("=" * 50)
    
    # Setup test data
    ll = LinkedList()
    values = [10, 20, 40, 50]
    for value in values:
        new_node = Node(value)
        if ll.head is None:
            ll.head = new_node
        else:
            current = ll.head
            while current.next:
                current = current.next
            current.next = new_node
        ll.size += 1
    
    print("Starting with:")
    ll.visualize()
    time.sleep(1)
    
    position = 2
    data = 30
    print(f"\n📍 INSERTING {data} AT POSITION {position}:")
    time.sleep(0.8)
    
    new_node = Node(data)
    current = ll.head
    for i in range(position - 1):
        print(f"Moving to position {i+1}: [{current.data}]")
        current = current.next
        time.sleep(0.6)
    
    print(f"Found position {position-1}: [{current.data}]")
    time.sleep(0.8)
    
    new_node.next = current.next
    current.next = new_node
    ll.size += 1
    
    print(f"Inserted [{data}] between [{current.data}] and next")
    time.sleep(0.8)
    
    ll.visualize()
    time.sleep(1)
    print("\n✅ SECTION 6 COMPLETE!")
    time.sleep(1)

# ============================================================
# SECTION 7: DELETING AT SPECIFIC POSITION
# ============================================================

def section7_delete_at_position():
    print("=" * 50)
    print("🗑️ SECTION 7: DELETE AT POSITION")
    print("=" * 50)
    
    # Setup test data
    ll = LinkedList()
    values = [10, 20, 30, 40, 50]
    for value in values:
        new_node = Node(value)
        if ll.head is None:
            ll.head = new_node
        else:
            current = ll.head
            while current.next:
                current = current.next
            current.next = new_node
        ll.size += 1
    
    print("Starting with:")
    ll.visualize()
    time.sleep(1)
    
    position = 2
    print(f"\n🗑️ DELETING AT POSITION {position}:")
    time.sleep(0.8)
    
    current = ll.head
    for i in range(position - 1):
        print(f"Moving to position {i+1}: [{current.data}]")
        current = current.next
        time.sleep(0.6)
    
    deleted_data = current.next.data
    print(f"Found node to delete: [{deleted_data}]")
    time.sleep(0.8)
    
    current.next = current.next.next
    ll.size -= 1
    
    print(f"Deleted [{deleted_data}]")
    time.sleep(0.8)
    
    ll.visualize()
    time.sleep(1)
    print("\n✅ SECTION 7 COMPLETE!")
    time.sleep(1)

# ============================================================
# SECTION 8: UPDATING A NODE
# ============================================================

def section8_updating():
    print("=" * 50)
    print("🔄 SECTION 8: UPDATING NODES")
    print("=" * 50)
    
    # Setup test data
    ll = LinkedList()
    values = [10, 20, 30, 40]
    for value in values:
        new_node = Node(value)
        if ll.head is None:
            ll.head = new_node
        else:
            current = ll.head
            while current.next:
                current = current.next
            current.next = new_node
        ll.size += 1
    
    print("Starting with:")
    ll.visualize()
    time.sleep(1)
    
    position = 2
    new_data = 25
    print(f"\n🔄 UPDATING POSITION {position} TO {new_data}:")
    time.sleep(0.8)
    
    current = ll.head
    for i in range(position):
        print(f"Moving to position {i+1}: [{current.data}]")
        current = current.next
        time.sleep(0.6)
    
    old_data = current.data
    print(f"Found node: [{old_data}]")
    time.sleep(0.8)
    
    current.data = new_data
    print(f"Updated from [{old_data}] to [{new_data}]")
    time.sleep(0.8)
    
    ll.visualize()
    time.sleep(1)
    print("\n✅ SECTION 8 COMPLETE!")
    time.sleep(1)

# ============================================================
# SECTION 9: SORTING A LINKED LIST
# ============================================================

def section9_sorting():
    print("=" * 50)
    print("🔄 SECTION 9: SORTING")
    print("=" * 50)
    
    # Setup test data
    ll = LinkedList()
    values = [30, 10, 40, 20]
    for value in values:
        new_node = Node(value)
        if ll.head is None:
            ll.head = new_node
        else:
            current = ll.head
            while current.next:
                current = current.next
            current.next = new_node
        ll.size += 1
    
    print("Starting with (unsorted):")
    ll.visualize()
    time.sleep(1)
    
    print("\n🔄 BUBBLE SORT:")
    time.sleep(0.8)
    
    swapped = True
    pass_num = 1
    
    while swapped:
        swapped = False
        current = ll.head
        print(f"\nPass {pass_num}:")
        time.sleep(0.8)
        
        while current.next:
            print(f"Comparing [{current.data}] and [{current.next.data}]", end="")
            time.sleep(0.6)
            
            if current.data > current.next.data:
                current.data, current.next.data = current.next.data, current.data
                swapped = True
                print(" ✓ Swapped!")
            else:
                print(" ✗")
            
            current = current.next
        
        if swapped:
            print(f"After pass {pass_num}: {ll}")
            time.sleep(0.8)
        
        pass_num += 1
    
    print(f"\nFinal sorted list:")
    ll.visualize()
    time.sleep(1)
    print("\n✅ SECTION 9 COMPLETE!")
    time.sleep(1)

if __name__ == "__main__":
    section1_linked_list_vs_array()
    print("\n" + "="*60 + "\n")
    section2_adding_nodes()
    print("\n" + "="*60 + "\n")
    section3_removing_nodes()
    print("\n" + "="*60 + "\n")
    section4_searching()
    print("\n" + "="*60 + "\n")
    section5_traversing()
    print("\n" + "="*60 + "\n")
    section6_insert_at_position()
    print("\n" + "="*60 + "\n")
    section7_delete_at_position()
    print("\n" + "="*60 + "\n")
    section8_updating()
    print("\n" + "="*60 + "\n")
    section9_sorting()