Structure Decision Mastery

This is the final lesson where you stop thinking: “list or set? dict or list?” and start thinking like a problem solver. A beginner usually chooses structures by habit. A good programmer chooses by **operations** (what you do most). ## The decision rule (the simplest one) Ask yourself these questions in order: 1) Do I need **key -> value** lookup? 2) Do I need **uniqueness** (no duplicates)? 3) Do I need **order** (sequence matters)? 4) Do I need **FIFO / LIFO / Priority** behavior? If you answer these correctly, your structure becomes obvious. ## Quick decision map (visual) ```mermaid flowchart TD A[What do you need?] --> B{Key -> value lookup?} B -->|Yes| C[dict] B -->|No| D{Need uniqueness?} D -->|Yes| E[set] D -->|No| F{Need order + indexing?} F -->|Yes| G[list] F -->|No| H{Fixed, unchangeable data?} H -->|Yes| I[tuple] H -->|No| J{Need FIFO (first in first out)?} J -->|Yes| K[deque queue] J -->|No| L{Need LIFO (last in first out)?} L -->|Yes| M[stack (list/deque)] L -->|No| N{Need highest/lowest priority first?} N -->|Yes| O[heapq priority queue] ``` --- # 1) Scenario Decisions (Real-world style) ## Scenario 1: “Keep events in order (timeline / logs)” ### Problem You are storing events as they happen, and later you display them in the same order. ### Best structure: list Because: - order matters - you append a lot - you read in order ```python events = [] events.append({"t": "10:00", "msg": "login"}) events.append({"t": "10:02", "msg": "viewed profile"}) print(events[0]["msg"]) # login ``` **Benefit:** simple, readable, keeps natural order. --- ## Scenario 2: “Track unique users online” ### Problem Same user may ping your server many times, but you want unique online users. ### Best structure: set Because: - duplicates should be removed automatically - membership check should be fast ```python online = set() online.add("Tom") online.add("Tom") # duplicate ignored online.add("Sarah") print(online) # {'Tom', 'Sarah'} (order not guaranteed) print("Tom" in online) # fast ``` **Benefit:** prevents duplicates, super fast membership. --- ## Scenario 3: “Lookup user profile by id (fast)” ### Problem You have an id, you want the user data instantly. ### Best structure: dict Because: - key -> value lookup - fast average reads ```python users = { 101: {"name": "Tom", "city": "Austin"}, 102: {"name": "Sarah", "city": "Miami"}, } print(users[101]["name"]) # Tom ``` Safe read: ```python print(users.get(999, {"name": "Unknown"})) ``` **Benefit:** avoids slow searching in lists. --- ## Scenario 4: “Undo feature (editor, form, user actions)” ### Problem You want to undo the latest action first. ### Best structure: stack (LIFO) Because: - last action should come out first ```python history = [] history.append("state1") history.append("state2") last = history.pop() print(last) # state2 ``` **Benefit:** perfect natural match for undo. --- ## Scenario 5: “Task processing (jobs in order)” ### Problem First task added should be processed first. ### Best structure: queue (FIFO) using deque Because: - FIFO behavior - efficient popleft() ```python from collections import deque q = deque() q.append("task1") q.append("task2") print(q.popleft()) # task1 ``` **Benefit:** real-world job systems use this idea. --- ## Scenario 6: “Urgent job first (priority scheduling)” ### Problem You don’t want FIFO, you want highest/lowest priority first. ### Best structure: heapq (priority queue) Because: - always pops smallest priority item first (or use negative for max) ```python import heapq pq = [] heapq.heappush(pq, (1, "urgent")) heapq.heappush(pq, (5, "low")) heapq.heappush(pq, (2, "medium")) while pq: p, task = heapq.heappop(pq) print(p, task) ``` **Benefit:** used in scheduling, routing, “top-k” problems. --- # 2) The “Wrong Structure” Mistakes (and why they hurt) ## Mistake A: Using list for membership-heavy checks ```python nums = list(range(1_000_000)) print(999_999 in nums) # slow compared to set ``` Fix: ```python nums_set = set(nums) print(999_999 in nums_set) # fast ``` ## Mistake B: Using set when you need stable ordering Sets don’t guarantee order for your logic. If order matters, use list (or sort). --- # 3) A “One Minute Cheat Sheet” - **list**: ordered, duplicates allowed, indexing needed - **tuple**: ordered, fixed data (immutable) - **set**: unique items, fast membership - **dict**: key -> value mapping, fastest lookup style - **deque**: queue/stack optimized ends - **heapq**: priority-based retrieval --- # Final takeaway (the mindset) Data structures are not “topics”. They are “tools”. Pick the tool based on the job: - order? list/tuple - uniqueness? set - lookup? dict - FIFO? deque - LIFO? stack - priority? heapq ## Congratulations You completed the intermediate level Data Structures playlist (35 tutorials).