A course doesn't end when the lessons run out, but when you know how to keep learning without it. In this lesson you get a curated, annotated library: official documentation, books, practice platforms, visualizers, and the topics that naturally continue what we've covered. It's not a list to read from top to bottom, but a map: for each resource I tell you what it offers and when to use it, so you can reach for the right one at the right moment. The lesson closes with a section on how to study with all of this, which matters more than the material itself.

1. Official Python documentation
2. Books: from the approachable to the reference
3. Practice platforms (and how to start without getting frustrated)
4. Visualizers
5. Natural next topics
6. Keep practicing with TaskFlow
7. How to study with these resources

Python's documentation is among the best in the industry and should be your first stop, not your last.

Tip: bookmark TimeComplexity. It's the official, always up-to-date version of the cost table we built in module 1.

Don't read them in parallel; each one has its moment.

• Grokking Algorithms (Aditya Bhargava). The most approachable book there is: it explains binary search, hashing, BFS, Dijkstra, graphs... with drawings. Examples in Python. When: right now, as you finish this course — it will serve as a review from another angle and gently introduce dynamic programming and NP problems, which we haven't touched here. It reads in a couple of weeks.
• Problem Solving with Algorithms and Data Structures using Python (Miller and Ranum; free online at runestone.academy). Covers nearly the same syllabus as this course, with complete Python implementations and interactive exercises that run in the browser. When: as a second pass through the syllabus; reading someone else's implementation of a HashTable or an AVL, different from yours, consolidates enormously. It's the natural reference for "the course as told by someone else".
• Introduction to Algorithms (Cormen, Leiserson, Rivest, Stein — "CLRS"). The academic reference: formal proofs, rigorous analysis, pseudocode. Over 1,300 pages. When: NOT to read cover to cover now. Use it as an encyclopedia: when you need to deeply understand a specific algorithm (why Dijkstra fails with negative weights, the amortized analysis of the dynamic array), its chapter will be the definitive explanation. Buy it or consult it at a library; it's intimidating, but every chapter is self-contained.

Structures stick by solving problems. But the number-one mistake is to enter a platform, open a random "medium" problem, get stuck and conclude that "this isn't for me". A concrete plan:

• LeetCode (leetcode.com). The de facto standard for interview prep. What matters: problems are tagged by structure (stack, queue, hash-table, heap-priority-queue, binary-search-tree, graph...) and by difficulty. How to start: filter by a tag you're strong in (e.g. stack) + Easy difficulty, and solve 5-10 problems of that tag before switching. You'll recognize old friends: "Valid Parentheses" is your is_balanced_filter; "Min Stack" is your MinStack; "Course Schedule" is your has_cycle + topological order.
• HackerRank (hackerrank.com). Similar, with guided paths (the "Data Structures" track) that move from easy to hard more gradually than LeetCode. A good entry point if LeetCode feels dry.
• Exercism (exercism.org). Free, with human mentors who review your code and an excellent Python track. Less oriented to pure algorithms and more to writing clean Python. Ideal for polishing style while you practice.

Rules for staying sane, valid on any platform:

1. Easy first, and no shame. Ten easy problems solved teach more than one hard problem abandoned.
2. A stuck-time limit: 30-45 minutes of serious attempt; then look at the solution, understand it, close it, and rewrite it yourself from memory. Looking at solutions isn't cheating; looking without rewriting is.
3. One tag per week. Practice grouped by structure builds the problem→structure reflex we trained in 08-01.
4. Come back to solved problems one or two weeks later. If you can't do it the second time, it wasn't learned.

Watching a structure move is worth more than rereading its description:

• VisuAlgo (visualgo.net). Step-by-step animations of almost the entire course: linked lists, stacks, queues, hash tables (with collisions and rehashing!), BSTs, AVL trees with their rotations, heaps, BFS/DFS, Dijkstra, Prim, Kruskal... When: while reviewing an algorithm you remember "more or less" — watching the AVL rotations animated clarifies in two minutes what takes half an hour on paper. It has an exam mode for self-assessment.
• Python Tutor (pythontutor.com). Runs your own Python code step by step while drawing the memory: references, objects, the call stack growing and shrinking with each recursive call. When: to debug your understanding, not just your code. Paste your LinkedList from module 2 and watch the nodes point at each other; paste a recursive traversal and watch the call stack we studied in module 3 become visible.

The course leaves you at the frontier of several paths. Ordered by continuity with what you already know:

Don't try to tackle them all: pick one (for a junior profile, sorting or dynamic programming are the highest-yield bets) and give it a month.

TaskFlow is yours: the best practice field is extending it. Ideas ordered from least to most effort, each tied to what it exercises:

• Persistence: save and load the tasks as JSON, measuring with timeit how much it costs to rebuild the indexes at startup (modules 1 and 5).
• Trash bin with expiry: deleted tasks recoverable for N actions — a deque(maxlen=N) of (task, action at which it was deleted) tuples (modules 3 and 4).
• Hierarchical tags: make work/backend inherit searches from work — a general tree + inverted index collaborating (modules 5 and 6).
• Scheduled reminders: a heap keyed by due date that fires alerts — your UrgentInbox with time as the priority (modules 4 and 6).
• Multi-user mode: a collaborator graph (who has worked with whom) with an improved suggest_collaborators (module 7).
• A real LRU cache for frequent searches: implement the design from exercise 3 of 08-01 and compare it with functools.lru_cache (modules 2 and 5).

The next lesson turns three of these threads into complete projects with requirements and evaluation criteria.

We adapt the usual section: here the mistakes are about how you use the resources.

• Collecting instead of studying. Saving 40 links produces the same improvement as saving zero. Rule: at most one book, one platform and one visualizer active at a time.
• The "infinite tutorial". Chaining courses and videos without solving problems is the most comfortable way to not advance. Healthy ratio: for every hour of reading/video, at least one hour at the keyboard.
• Spaced practice, not binges. Twenty minutes a day for a month sticks better than one eight-hour Saturday. Forgetting is the mechanism: reviewing just when you begin to forget (after 2 days, a week, a month) is what consolidates.
• Implement from memory. The ultimate test of a structure isn't reading it: it's closing everything and writing your HashTable or your BFS in an empty editor. Do it with a different structure each week.
• Explain to others. Write a short article, answer a question on a forum, or explain heaps to a colleague. If you can't explain it without looking, it wasn't yours yet (and explaining is reviewing).
• Treat frustration as a signal, not a verdict. Getting stuck is the normal state of learning algorithms. The question isn't "am I getting stuck?" but "am I getting stuck on harder things than a month ago?".

Draw up your study plan for the next 4 weeks using only resources from this lesson: choose one book, one platform with a specific starting tag, and one "natural next" topic, and justify each choice in one sentence based on the weak spot you detected in the 08-02 quiz.

Go to the TimeComplexity wiki and answer using it (not from memory): (a) what does x in s cost for a set in the average case and in the worst case? (b) which deque operation is O(n) despite the structure's "everything O(1)" reputation? (c) does the worst case of dict.get match what you learned in module 5 about collisions?

In VisuAlgo, AVL section, insert the sequence 1, 2, 3, 4, 5, 6, 7 and note which rotation each insertion triggers. Then predict on paper what will happen with the sequence 7, 6, 5, 4, 3, 2, 1 and verify it in the visualizer.

Exercise 1. There is no single right answer; a typical plan for a profile that missed the tree questions in the quiz: Problem Solving with A&DS (the tree chapters, because it provides a complete second implementation), LeetCode tag binary-search-tree on Easy difficulty (grouped practice on the weak spot), and "sorting in detail" as the next topic (it capitalizes on the Heap you already built, via heapsort). The essential thing is that each choice is justified by your diagnosis, not by popularity.

Exercise 2. (a) O(1) average, O(n) worst case — the worst case happens when all keys collide. (b) Access by index at middle positions, d[i], is O(n) (and so are insert/remove in the middle): the deque optimizes the ends, not the interior. (c) Yes: the O(n) worst case of dict.get is exactly the massive-collision scenario of module 5 — all keys in the same bucket form a chain that must be walked; rehashing and a good hash function make it improbable, not impossible.

Exercise 3. With 1..7 ascending, every imbalance is right-right and is fixed with single left rotations (they fire on inserting 3, 5 — a local rebalance —, 6 and 7, depending on the tree's state). The prediction for 7..1: the mirror case — left-left imbalances, single right rotations at the symmetric points, and a final tree with the same balanced shape. If your notes differ on exactly which insertion triggers each rotation but you got the rotation type and the symmetry right, the concept is learned.

You now have the library: the official documentation as your daily reference, Grokking and the Runestone book as your next reads, CLRS as the encyclopedia, LeetCode/HackerRank/Exercism as the gym, VisuAlgo and Python Tutor as the microscope, and a short list of topics to grow through. Remember the rule running through this whole lesson: few resources, lots of practice, spaced and from memory. Only one thing remains to be done in this course, and it's the most important: build. The three final projects await you in the last lesson.