Final Thoughts on Learn Data Structures and Algorithms with Golang

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.

What the Book Covers

Quick recap. The book walks through three main sections:

1. Foundations - what data structures are, how to classify them, and getting your Go environment ready
2. Core structures - linear stuff like lists and stacks, non-linear things like trees and hash tables, arrays, linked lists, dictionaries, and classic sorting/searching algorithms
3. Advanced topics - graphs, sparse matrices, memory management, and garbage collection

That’s a lot of ground. Ten chapters covering pretty much every data structure you’d encounter in a CS course or coding interview.

What Worked

Go as the teaching language. Most DSA books use Java, Python, or C++. Seeing everything in Go was refreshing. Go’s simplicity means the code examples are usually short and readable. You’re not fighting the language to understand the concept.

Breadth of coverage. The book doesn’t skip stuff. You get everything from basic arrays to AVL trees to garbage collection algorithms. If you want one book that touches all the main data structures, this does the job.

Code examples throughout. Every concept comes with actual Go code. Not pseudocode, not hand-wavy descriptions. Real code you can run.

What Could Be Better

The writing is dense. Some chapters read more like reference material than a tutorial. If you’re completely new to programming, you might struggle with some explanations that assume prior knowledge.

Code quality varies. Some examples are clean and well-structured. Others feel rushed or use patterns that aren’t idiomatic Go. The book was published in 2019, and Go has evolved since then. Some things would be done differently today with modern Go (generics, for example, didn’t exist yet).

Performance analysis is surface-level. The book mentions Big O complexity for most operations but doesn’t always explain the “why” behind the numbers. If you want deep algorithm analysis, you’ll need a dedicated algorithms textbook alongside this one.

Who Should Read This

Go developers who want DSA fundamentals. If you already know Go and want to fill gaps in your CS knowledge, this is a solid starting point.

Interview preppers. The book covers the core data structures and algorithms that come up in technical interviews. Having Go implementations ready to reference is useful.

Students switching to Go. If you learned DSA in another language and want to see how things map to Go, this gives you that translation.

Who Should Skip This

If you’ve never programmed before, start somewhere else. This book assumes you can at least read code and understand basic programming concepts.

If you need deep algorithm analysis with mathematical proofs, look at “Introduction to Algorithms” (CLRS) instead. This book is more practical than theoretical.

The Series

Here’s everything we covered:

1. Series Introduction
2. Chapter 1 Part 1: What Are Data Structures?
3. Chapter 1 Part 2: Algorithms and Performance
4. Chapter 2 Part 1: Go Basics for Data Structures
5. Chapter 2 Part 2: Slices, Maps, and Go Patterns
6. Chapter 3 Part 1: Lists, Sets, and Tuples
7. Chapter 3 Part 2: Stacks, Queues, and Heaps
8. Chapter 4 Part 1: Trees in Go
9. Chapter 4 Part 2: Hash Tables and Functions
10. Chapter 5 Part 1: Arrays and Multi-Dimensional Arrays
11. Chapter 5 Part 2: Matrix Operations
12. Chapter 6 Part 1: Singly and Doubly Linked Lists
13. Chapter 6 Part 2: Circular and Ordered Lists
14. Chapter 7 Part 1: Dictionaries and TreeSets
15. Chapter 7 Part 2: Sequences and Anti-Patterns
16. Chapter 8 Part 1: Sorting Algorithms
17. Chapter 8 Part 2: Searching, Recursion, and Hashing
18. Chapter 9 Part 1: Graphs and Network Representation
19. Chapter 9 Part 2: Sparse Matrices and Real-World Uses
20. Chapter 10 Part 1: Memory Management and GC
21. Chapter 10 Part 2: Cache and Space Allocation

Bottom Line

“Learn Data Structures and Algorithms with Golang” is a decent reference book for Go developers who want to understand the building blocks of computer science. It’s not perfect, and the writing style can be dry at times. But the combination of Go + comprehensive DSA coverage makes it worth picking up if that’s what you need.

Book: Learn Data Structures and Algorithms with Golang Author: Bhagvan Kommadi Publisher: Packt Publishing, March 2019 ISBN: 978-1-78961-850-1

Thanks for following along with this series. If you found it useful, check out the other book retellings on this site.

Previous: Chapter 10 Part 2: Cache and Space Allocation