Learn the algorithms and the language together, in Go’s own style.
Most DSA material is written for Java or Python and translated. This book starts from Go: slices, maps, structs and pointers, runes and the standard library. Every chapter has a complete program you can run, the cost of each approach in time and memory, and exercises with solutions.
Count, look up and de-duplicate with Go maps, and learn what a missing key returns before it surprises you.
Choose the right unit for text problems, so a loop over a string counts what you think it counts.
Build linked lists and trees from structs and pointers, and see when passing a pointer matters.
Implement a min-heap yourself, then use container/heap once you know what it does.
Each chapter has a complete program to run, the time and memory cost, and exercises.
Set up Go, a terminal and an editor, and run your first program.
Enough Go for your first algorithms: variables, conditions, loops, functions and slices.
Count values, test membership, and replace a repeated scan with a lookup.
Pick bytes, runes or characters so text algorithms count the right thing.
Model linked nodes and see the difference between a struct value and a pointer.
Find the smaller problem and the stopping condition, and count the stack space.
Newest first or oldest first, built on slices, with the memory trap in slice queues.
Build a singly linked list, trace pointer changes, and know when a list is worth it.
How a key finds its slot, what happens on a collision, and what a map lookup really costs.
Tree vocabulary, three depth-first traversals, and when a BST is actually fast.
Implement a min-heap and recognise Go’s container/heap interface.
Binary search without off-by-one mistakes, and what sorting costs.
Three ways to stop rescanning the same elements, and when each one applies.
Split a problem into smaller ones, and search choices while undoing each cleanly.
Represent a graph, visit each vertex once, and find shortest paths with BFS.
When locally best choices give the best answer, and how to justify the rule.
Define a state, write the recurrence and base cases, and compute the cost.
Choose a technique without a chapter title to help, and build a small route finder.
Debugging Is the Skill teaches a method for finding the bug instead of resubmitting, with sixteen planted bugs to practise on.
Explore the debugging book