marks = [72, 85, 90, 64]
print(marks[0])      # 72  (index starts at 0)
print(marks[-1])     # 64  (last item)
print(marks[1:3])    # [85, 90] (slice)

stack = []
stack.append("page1"); stack.append("page2")
print(stack.pop())   # page2 — last in, first out

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

a, b, c = Node("A"), Node("B"), Node("C")
a.next, b.next = b, c

node = a
while node:
    print(node.value, end=" -> ")
    node = node.next
print("None")    # A -> B -> C -> None

students = {"roll_42": "Asha", "roll_17": "Ravi"}
print(students["roll_42"])           # Asha
print("roll_99" in students)         # False — fast membership check
students["roll_99"] = "Meera"         # insert
print(len(students))                 # 3

# Sets also use hashing
seen = {"apple", "banana"}
print("apple" in seen)               # True

ok = {(1, 2): "tuple key works"}
print(ok[(1, 2)])

try:
    bad = {[1, 2]: "list key"}
except TypeError as e:
    print("Error:", e)    # unhashable type: 'list'
# Keys must be hashable (usually immutable) so their hash never changes

tree = {"A": ["B", "C"], "B": ["D", "E"], "C": [], "D": [], "E": []}

def dfs(node):                 # depth-first: go deep first
    print(node, end=" ")
    for child in tree[node]:
        dfs(child)

from collections import deque
def bfs(start):                # breadth-first: level by level
    q = deque([start])
    while q:
        n = q.popleft()
        print(n, end=" ")
        q.extend(tree[n])

dfs("A"); print()   # A B D E C
bfs("A"); print()   # A B C D E

Big-O cheat sheet (n = number of items)
O(1)       constant     dict lookup, list index
O(log n)   logarithmic  binary search, balanced tree lookup
O(n)       linear       scanning a list once
O(n log n) linearithmic efficient sorting
O(n²)      quadratic    nested loops over the same list
For n = 1,000,000: O(log n) ≈ 20 steps, O(n) = 1,000,000 steps.

Front                         | Back
Stack                         | LIFO — last in, first out
Queue                         | FIFO — first in, first out
Hash collision                | two keys map to the same slot
BST property                  | left < node < right
Min-heap                      | parent ≤ children; smallest on top
BFS                           | visit level by level (uses a queue)
DFS                           | go deep first (uses recursion/stack)
O(log n)                      | halves the problem each step

One practice problem per term
Array      → reverse a list in place
Stack      → check balanced brackets
Queue      → simulate a ticket line
Hash map   → count word frequencies
BST        → check if a value exists
Heap       → find the 3 largest numbers
Graph      → BFS shortest path in a grid
Big-O      → state the complexity of each solution

Explain each term in one sentence and one real example
Term: ______
Meaning: ______________
Real example: ______________
Python tool: ______________
Complexity of main operation: ______