Bhagvan Kommadi's guide to learning data structures and algorithms using Go, covering everything from basic arrays to garbage collection.
“Learn Data Structures and Algorithms with Golang” teaches the core building blocks of computer science using Go as the implementation language. Instead of the usual Java or Python examples, every data structure and algorithm is shown with actual Go code you can run and experiment with.
The book is split into three sections. Section one covers the basics, including what data structures are, how to classify them, and how to set up your Go environment. Section two gets into the core structures like lists, stacks, trees, hash tables, arrays, linked lists, dictionaries, and classic sorting and searching algorithms. Section three tackles advanced topics like graphs, sparse matrices, memory management, and garbage collection.
This is for Go developers who want to fill in their CS fundamentals, people prepping for technical interviews, or anyone who learned data structures in another language and wants to see how they work in Go. The book assumes you can already write basic code, so complete beginners should start elsewhere.
So I picked up this book called “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi (Packt Publishing, 2019, ISBN: 978-1-78961-850-1). And I’m going to retell the whole thing here on the blog, chapter by chapter.
Chapter 1 of the book jumps right into classifying data structures and showing some structural design patterns in Go. There’s a lot packed in here, so I’m splitting it into two parts. This first part covers what data structures are, how they’re classified, and a bunch of design patterns with Go code.
In Part 1 we covered what data structures are, how they get classified, and a bunch of structural design patterns. Now we’re getting to the fun stuff: algorithms, how to measure their performance, and a few classic algorithm types.
Welcome to Chapter 2 of our walkthrough of “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi. This is Part 1, where we cover the Go-specific building blocks you need before getting into the heavier data structure topics. Think of this as your toolkit chapter.
Welcome back. In Part 1 we covered arrays, basic slices, two-dimensional slices, and maps. That was the foundation. Now Kommadi moves into the more interesting Go patterns: variadic functions, defer and panic, and a full CRUD web application that ties it all together. He also shows more advanced slice operations along the way.
Chapter 3 is where the book starts getting into the real stuff. We’re past the basics of Go syntax and data types, and now it’s time to build actual data structures from scratch. This first half covers three linear data structures: linked lists (both single and double), sets, and tuples.
Welcome back. In the first half of Chapter 3, we covered linked lists, sets, and tuples. Now we’re finishing the chapter with queues, stacks, and heaps. These three come up constantly in real software, from job schedulers to undo buttons to sorting algorithms. Let’s get into it.
Up to this point in the book, everything we covered was linear. Lists, stacks, queues, heaps, all of them store data in a straight line. One element after another. Chapter 4 is where things get interesting because we’re moving into non-linear data structures.
Welcome back. In Part 1 we covered binary search trees and AVL trees. Now we’re finishing up Chapter 4 of “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi. This second half covers B-trees, B+ trees, tables, containers, circular linked lists, and hash functions.
Chapter 5 of “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi shifts gears from trees and hash tables into something more math-heavy: homogeneous data structures. That basically means data structures where every element is the same type. Think arrays of integers, matrices of floats, that kind of thing.
Welcome back to Part 2 of Chapter 5 from “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi. In Part 1 we looked at arrays and multi-dimensional arrays. Now we get into the fun stuff: matrix operations, special matrix types, and tensors.
Chapter 6 of “Learn Data Structures and Algorithms with Golang” is all about heterogeneous data structures. That’s a fancy way of saying “data structures that can hold different types of data.” Think integers, floats, strings, whatever you need, all mixed together. Linked lists and ordered lists are the main examples here.
Welcome back to Chapter 6 of “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi. In Part 1 we covered singly and doubly linked lists. Now we pick up where we left off: circular linked lists, ordered lists, and unordered lists.
We’re into Chapter 7 of “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi, and this is where things get interesting. The chapter is about dynamic data structures, which are basically collections that can grow and shrink as needed. No fixed sizes, no guessing how much memory you need upfront.
Welcome back. In Part 1 we went through dictionaries and TreeSets. This second half of Chapter 7 wraps up TreeSets with synchronized and mutable variants, then moves into some cool mathematical sequences implemented in Go. We also talk about common anti-patterns the book warns about when working with these data structures.
Chapter 8 of “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi is called “Classic Algorithms.” It covers sorting, searching, recursion, and hashing. That’s a lot of ground, so we’re splitting it into two parts. This first part is all about sorting.
Welcome back. In Part 1 we covered the sorting side of Chapter 8, from bubble sort all the way to quick sort. Now we’re picking up the second half: searching algorithms, recursion, and hashing. These are the tools you use when you already have your data and need to find stuff in it, or when you need to transform it for fast lookups.
Chapter 9 of “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi shifts gears into graphs and network structures. If you’ve been following along, we spent the last few chapters on searching, sorting, and hashing. Now we’re getting into something that models the real world more directly: connections between things.
Welcome back. In Part 1 we covered graph fundamentals, social networks, and map layouts. Now Kommadi finishes Chapter 9 with two more practical topics: knowledge graphs and sparse matrix representation. Both build on the graph foundation from Part 1, but they’re different enough to deserve their own discussion.
We’ve spent nine chapters building data structures, stacking nodes, balancing trees, linking lists. But here’s a question we haven’t really asked yet: what happens to all that memory when we’re done with it?
Welcome back. In Part 1 we went through garbage collection algorithms, reference counting, mark-and-sweep, and generational collection. Now let’s finish up Chapter 10 of “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi. This second half covers cache management, space allocation on the stack, pointers, memory management tips, and profiling.
And that’s a wrap. We made it through all 10 chapters of “Learn Data Structures and Algorithms with Golang” by Bhagvan Kommadi. Here’s what I think after spending time with this book.