Algorithms and Data Structures
30 articles
Open Addressing Hash Tables and Swiss Tables
Explore open addressing, Swiss tables, collision resolution techniques, and cache-efficient hash table design.
Implementing Sliding Window
Implement sliding window algorithms for efficient subarray searching with optimized time complexity and rate limiter applications.
Search Patterns in Binary Search Trees
Learn DFS and BFS search patterns for binary search trees, including preorder, inorder, and postorder traversal methods.
About the Two Pointer Technique
Master two-pointer technique for efficient array pair searching with O(N log N) complexity using sorting and index manipulation.
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.
Implementation of Counting Sort
Implement counting sort using prefix sums in Go. Discover non-comparison sorting with efficient O(n) time complexity execution.
Implementing Backtracking
Implement backtracking algorithm to explore constraint-satisfying combinations using recursive tree structures and subsequence generation.
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 - Bubble Sort
Learn Bubble Sort, a comparison-based sorting algorithm with O(n²) time complexity. Covers the adjacent-element swap logic and a complete Go implementation.
Algorithms and Data Structures - Heap Sort
Learn Heap Sort, which uses a binary heap tree to sort in O(n log n) time. Covers heap construction, root extraction, and a Go implementation.
Algorithm and Data Structures - Insertion Sort
Learn Insertion Sort, which divides the array into sorted and unsorted parts and builds the sorted sequence one element at a time. O(n²) time complexity with a Go implementation.
Algorithms and Data Structures - Merge Sort
Learn Merge Sort, a divide-and-conquer sorting algorithm with O(n log n) worst-case time complexity. Covers recursive splitting, merging steps, and a Go implementation.
Algorithms and Data Structures - Quick Sort
Understand Quick Sort: O(n log n) average, O(n²) worst-case time complexity. Covers pivot selection, partitioning into low/high ranges, and a randomized Go implementation.
Algorithms and Data Structures - Selection Sort
Understand Selection Sort, which repeatedly finds the minimum element and swaps it into position. Covers O(n²) time complexity and a Go implementation.
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.