#Data Structures
21 articles
Exploring Processes, Goroutines, and Memory in Go
Explore Go virtual address spaces, process isolation, goroutine memory sharing, stack and heap behavior.
Open Addressing Hash Tables and Swiss Tables
Explore open addressing, Swiss tables, collision resolution techniques, and cache-efficient hash table design.
Search Patterns in Binary Search Trees
Learn DFS and BFS search patterns for binary search trees, including preorder, inorder, and postorder traversal methods.
Algorithms and Data Structures - HashMap
Understand how HashMaps work: O(1) average access, open addressing vs. chaining for hash collision handling, and a basic Go HashMap implementation.
Adjacency List and Adjacency Matrix
Compare adjacency lists (O(V+E) space, efficient for sparse graphs) and adjacency matrices (O(V²) space, O(1) edge lookup). Includes Go implementations for directed and undirected graphs.
Implementation of Stack and Queue
Implement stack and queue data structures in Go with linked lists and slices for O(1) operations and optimal performance.
Runner Technique for Linked Lists
A summary of the runner technique, useful for traversing linked lists. I first learned about this approach of advancing two pointers through the list at different speeds in the book Cracking the Coding Interview, and this article explains the idea and where it comes in handy.
Reviewing the Basics of Algorithms and Data Structures
A comprehensive review of algorithms and data structures basics: arrays, strings, hash tables, linked lists, trees, stacks, queues, sorting, and time complexity for coding problems.
Algorithm Encyclopedia Revised Edition: 33 Algorithms Illustrated
A review of the illustrated algorithm guide covering 33 algorithms including sorting and searching. It explains them clearly with diagrams at the center, letting you grasp their behavior intuitively and making it a reference worth keeping close.
Algorithms and Data Structures - Binary Search Trees
Understand Binary Search Trees: O(log n) average search and insertion, DFS (preorder, inorder, postorder) and BFS traversal methods with a Go BST implementation.
Algorithms and Data Structures - Heap
Learn how min-heaps and max-heaps work as priority queue data structures. Covers O(log n) insertion and deletion with a Go heap implementation.
Algorithms and Data Structures - Queue
Learn how the Queue (FIFO) data structure works. Covers enqueue and dequeue operations, time complexity compared to stacks, and a Go implementation.
Algorithms and Data Structures - Stack
Learn how the Stack (LIFO) data structure works. Covers push, pop, and peek operations with time complexity analysis, and a complete Go implementation using slices.
Algorithms and Data Structures - Arrays
Understand arrays as a data structure: O(1) random access, O(n) insertion/deletion, static vs. dynamic memory allocation. Includes a Go array implementation.
Algorithms and Data Structures - Lists
Learn how singly linked lists work: O(n) access vs. O(1) insertion/deletion, pointer-based node traversal, and a Go implementation of a linear linked list.
Implementing a Trie in Golang
Learn how Trie (prefix tree) data structures work: O(m) search and insertion, applications in HTTP routing and IP lookups, and a Go implementation of insert and search operations.
Everyone's Computer Science
A review of Everyone's Computer Science. A book for compactly grasping the big picture of computer science by its key points. Rather than diving deep into each topic, it is just right when you want a map of the CS field.
Creating URL Routing Episode 3 (Final Episode)
Build PHP URL routing systems with path parameters, HTTP methods, tree-based search algorithms, and complete endpoint handling.
Creating URL Routing Episode 2
Implement optimized URL routing with refined tree structure patterns, endpoint mapping, and scalable web application routing logic.
Creating URL Routing Episode 1
Master URL routing using tree structures for HTTP request matching, path parameters, and efficient web application request handling.