# hoanhan101/algo

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/hoanhan101-algo).**

_How this analysis was created: the description and tags below were written by an AI model that read this project's README and public documentation pages; stars, license and language come straight from the GitHub API. The model does not read the source code._

3,678 stars · 370 forks · Go · MIT

## Links

- GitHub: https://github.com/hoanhan101/algo
- Homepage: https://hoanhan.co/posts/101-challenges
- awesome-repositories: https://awesome-repositories.com/repository/hoanhan101-algo.md

## Description

This project is a Go algorithm implementation library and a reference for data structures. It serves as a collection of solved coding interview problems and an algorithmic pattern collection, providing a reference of over 100 common challenges implemented in Go.

The library focuses on specific problem-solving strategies, including sliding windows, two pointers, and dynamic programming. It provides coded examples of standard sorting, searching, and graph traversal techniques to facilitate the study of algorithmic patterns.

The repository covers a broad range of capabilities, including array and string manipulation, custom data structure implementations, and tree operations. It also includes routines for linked list manipulation, dynamic programming optimizations, and interval-based sorting and searching.

## Tags

### Education & Learning Resources

- [Interview-Focused Problem Sets](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/cs-theory-foundations/algorithms/general-collections-and-study/algorithmic-problem-sets/interview-focused-problem-sets.md) — A reference of over 100 common algorithmic challenges and their solutions for technical interview preparation.
- [Algorithmic Reference Implementations](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/cs-theory-foundations/algorithms/general-collections-and-study/algorithmic-reference-implementations.md) — Providing coded examples of standard sorting, searching, and graph traversal techniques for use as a technical guide.
- [Algorithmic Patterns](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/algorithmic-patterns.md) — Applying specific strategies such as sliding windows, two pointers, and dynamic programming to solve complex computational tasks.
- [Go Data Structure Implementations](https://awesome-repositories.com/f/education-learning-resources/go-data-structure-implementations.md) — Implementing fundamental organization patterns like linked lists, binary trees, and heaps using the Go programming language.
- [Bracket Validation Algorithms](https://awesome-repositories.com/f/education-learning-resources/bracket-validation-algorithms.md) — Implements algorithms to verify correct pairing and ordering of brackets in strings using stack-based parsing. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/bracket_validator_test.go))
- [Depth Calculations](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/depth-calculations.md) — Calculates the maximum distance from the root to a leaf in a binary tree. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/max_depth_test.go))
- [Minimum](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/depth-calculations/minimum.md) — Finds the shortest path from the root to the nearest leaf using level-order traversal. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/min_depth_test.go))
- [Level-Order Traversals](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/level-order-traversals.md) — Extracts binary tree values level by level and organizes them into separate sub-arrays. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/level_order_traversal_test.go))
- [Level Average Calculations](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/level-order-traversals/level-average-calculations.md) — Computes the average value of nodes at each depth using level-order traversal. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/level_avg_test.go))
- [Successor Identifications](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/level-order-traversals/successor-identifications.md) — Locates the node immediately following a target node in a binary tree's level-order sequence. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/level_order_successor_test.go))
- [Balance Verification](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/cs-theory-foundations/data-structure-implementations/data-structures/balanced-search-trees/balance-verification.md) — Determines if a binary tree is height-balanced by calculating the depth difference between subtrees. ([source](https://github.com/hoanhan101/algo/blob/master/lab/balanced_binary_tree_test.go))
- [In-Place Word Reversal Algorithms](https://awesome-repositories.com/f/education-learning-resources/in-place-word-reversal-algorithms.md) — Rearranges characters representing words into the correct sequence by performing a global and individual reverse in place. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/reverse_word_test.go))
- [Nesting Level Analyzers](https://awesome-repositories.com/f/education-learning-resources/nesting-level-analyzers.md) — Locates the closing parenthesis corresponding to an opening one by tracking the nesting level. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/parenthesis_matching_test.go))
- [Number Property Algorithms](https://awesome-repositories.com/f/education-learning-resources/number-property-algorithms.md) — Determines if a number reaches one by repeatedly replacing it with the sum of its squared digits. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/happy_number_test.go))
- [Stack-Based Queues](https://awesome-repositories.com/f/education-learning-resources/queue-implementations/stack-based-queues.md) — Simulates first-in-first-out behavior by managing two stacks to handle enqueuing and dequeuing operations. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/queue_two_stacks_test.go))
- [Zigzag Traversals](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/technical-academic-domains/algorithmic-design-analysis/tree-data-structures/tree-traversal-utilities/zigzag-traversals.md) — Iterates through a binary tree while alternating the direction of node collection at each depth. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/zigzag_traversal_test.go))
- [Technical Interview Preparation](https://awesome-repositories.com/f/education-learning-resources/technical-interview-preparation.md) — Solving a curated set of common coding challenges in Go to practice algorithmic thinking and problem solving.

### Scientific & Mathematical Computing

- [Data Structure Implementations](https://awesome-repositories.com/f/scientific-mathematical-computing/data-structure-implementations.md) — Implementations of core computer science structures including linked lists, binary trees, heaps, and hash tables in Go.
- [Array Product Transformations](https://awesome-repositories.com/f/scientific-mathematical-computing/array-product-transformations.md) — Computes a list where each index contains the product of all other elements without using division. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/product_of_others_test.go))
- [Binary Sequence Optimizers](https://awesome-repositories.com/f/scientific-mathematical-computing/binary-sequence-optimizers.md) — Calculates the longest contiguous sequence of ones possible by replacing a limited number of zeros. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/longest_substring_ones_replacement_test.go))
- [Combinatorial Product Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/combinatorial-product-algorithms.md) — Implements a greedy tracking approach to find the maximum product of three integers in a list. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/highest_product_of_three_test.go))
- [Maximum-Tracking Stacks](https://awesome-repositories.com/f/scientific-mathematical-computing/data-structure-implementations/stack-implementations/maximum-tracking-stacks.md) — Returns the largest element in a stack in constant time using a secondary stack of maximums. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/largest_stack_test.go))
- [Greedy Sequence Optimizers](https://awesome-repositories.com/f/scientific-mathematical-computing/greedy-sequence-optimizers.md) — Determines the highest gain from buying and selling a stock using a greedy linear scan. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/apple_stocks_test.go))
- [Cycle Start Locators](https://awesome-repositories.com/f/scientific-mathematical-computing/linked-list-cycle-detectors/cycle-start-locators.md) — Implements logic to identify the exact node where a cycle begins within a linked list. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/cycle_start_test.go))
- [Palindrome Permutation Validators](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/string-algorithms/palindromic-sequence-analyzers/palindrome-permutation-validators.md) — Implements algorithms that check if a string can be rearranged into a palindrome by counting character frequencies. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/permutation_palindrome_test.go))
- [Sequence Calculators](https://awesome-repositories.com/f/scientific-mathematical-computing/sequence-calculators.md) — Computes the nth Fibonacci number using memoization or iterative approaches to optimize performance. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/fibonacci_numbers_test.go))
- [Subset Generation](https://awesome-repositories.com/f/scientific-mathematical-computing/set-theory-algorithms/nested-subset-enumerators/subset-generation.md) — Provides algorithms for computing all possible unique subsets of a given set. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/subsets_test.go))
- [Unique Subset Generation](https://awesome-repositories.com/f/scientific-mathematical-computing/set-theory-algorithms/nested-subset-enumerators/unique-subset-generation.md) — Implements logic for generating all possible subsets of a collection while preventing duplicate subsets. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/subsets_duplicates_test.go))
- [Sliding Window Averaging](https://awesome-repositories.com/f/scientific-mathematical-computing/sliding-window-averaging.md) — Computes the average of all fixed-size contiguous subarrays using a sliding window technique. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/avg_subarray_test.go))
- [Rotated Sorted Array Search](https://awesome-repositories.com/f/scientific-mathematical-computing/sorted-array-management/rotated-sorted-array-search.md) — Identifies the rotation point of a sorted list of words using binary search. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/find_rotation_point_test.go))
- [Sorted Array Pair Sum Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/sorted-array-pair-sum-algorithms.md) — Identifies two indices in a sorted array that sum to a target value using two pointers. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/pair_target_sum_test.go))
- [Distinct Element Subarray Counting](https://awesome-repositories.com/f/scientific-mathematical-computing/subarray-sum-algorithms/distinct-element-subarray-counting.md) — Implements sliding window algorithms for counting subarrays containing a limited number of unique elements. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/fruits_baskets_test.go))
- [Maximum Subarray Sums](https://awesome-repositories.com/f/scientific-mathematical-computing/subarray-sum-algorithms/minimum-length-subarray-sums/contiguous-subarray-processing/maximum-subarray-sums.md) — Provides algorithms for finding the contiguous subarray with the largest total sum. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/max_subarray_test.go))
- [Shortest Subarray Sum Locators](https://awesome-repositories.com/f/scientific-mathematical-computing/subarray-sum-algorithms/shortest-subarray-sum-locators.md) — Calculates the shortest contiguous subarray whose elements sum to a target value using a dynamic sliding window. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/smallest_subarray_test.go))

### Software Engineering & Architecture

- [Dynamic Programming](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-programming.md) — Breaks complex problems into smaller subproblems and stores their results to avoid redundant recursive calculations.
- [Heaps](https://awesome-repositories.com/f/software-engineering-architecture/heaps.md) — Utilizes max or min heaps to maintain sorted access to the most extreme elements in a dataset.
- [Pointer Manipulations](https://awesome-repositories.com/f/software-engineering-architecture/linked-lists/linked-list-manipulation-utilities/pointer-manipulations.md) — Rearranges data by updating node references in place to reverse sequences or reorder elements.
- [Sliding Window Patterns](https://awesome-repositories.com/f/software-engineering-architecture/sliding-window-patterns.md) — Maintains a dynamic range of elements to compute sums or unique counts without re-scanning the entire input.
- [Cyclic Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/linear-time-integer-sorts/cyclic-sorts.md) — Implements cyclic sort patterns to place elements at target indices for identifying missing or duplicate values. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/cyclic_sort_test.go))
- [Two-Pointer Strategies](https://awesome-repositories.com/f/software-engineering-architecture/two-pointer-strategies.md) — Uses multiple indices moving at different speeds or directions to find targets or detect cycles in linear time.
- [Knapsack Problem Solving](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/knapsack-problem-solving.md) — Calculates the maximum value from items with specific weights without exceeding a limit using dynamic programming. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/knapsack_test.go))
- [Two-Sum Solvers](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/knapsack-problem-solving/partition-problem-solving/two-sum-solvers.md) — Determines if two distinct elements in a list add up to a target value using a hashmap for constant-time lookups. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/inflight_test.go))
- [Combination Sum Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/combination-sum-algorithms.md) — Computes the total ways to reach a target sum using specific coin denominations via dynamic programming. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/making_change_test.go))
- [Subset Partitioning](https://awesome-repositories.com/f/software-engineering-architecture/combinatorial-subsets/subset-partitioning.md) — Determines if a collection of numbers can be split into two subsets with equal sums using dynamic programming. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/equal_subset_partition_test.go))
- [Word Frequency Counters](https://awesome-repositories.com/f/software-engineering-architecture/frequency-counting-algorithms/word-frequency-counters.md) — Calculates the frequency of each word in a sentence by tracking counts within a hashmap. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/word_cloud_test.go))
- [Median Tracking](https://awesome-repositories.com/f/software-engineering-architecture/heaps/median-tracking.md) — Tracks a flow of numbers using dual heaps to retrieve the current median in constant time. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/median_number_stream_test.go))
- [Collection Shuffling](https://awesome-repositories.com/f/software-engineering-architecture/in-place-array-manipulations/collection-shuffling.md) — Implements algorithms for randomly rearranging the order of elements within a contiguous memory buffer. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/inplace_shuffle_test.go))
- [Duplicate Detection in Arrays](https://awesome-repositories.com/f/software-engineering-architecture/in-place-array-manipulations/duplicate-limiting-in-sorted-arrays/duplicate-detection-in-arrays.md) — Identifies repeated integers in an array using a swap-to-index strategy. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/duplicate_test.go))
- [Unique Element Filtering](https://awesome-repositories.com/f/software-engineering-architecture/in-place-array-manipulations/duplicate-limiting-in-sorted-arrays/unique-element-filtering.md) — Implements algorithms for removing all duplicate elements from a sorted array to keep only unique values. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/remove_duplicates_test.go))
- [Interval Overlap Detection](https://awesome-repositories.com/f/software-engineering-architecture/interval-overlap-detection.md) — Provides algorithms to detect overlapping time intervals by sorting and comparing boundaries. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/conflict_appointment_test.go))
- [Intersection Identifications](https://awesome-repositories.com/f/software-engineering-architecture/interval-overlap-detection/intersection-identifications.md) — Identifies specific overlapping segments between two sorted lists of intervals. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/intervals_intersection_test.go))
- [Linked List Node Retrieval Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/linked-list-node-retrieval-algorithms.md) — Implements algorithms for locating nodes at specific positions, such as the kth to last element, in linked lists. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/kth_to_last_test.go))
- [Linked List Analysis Utilities](https://awesome-repositories.com/f/software-engineering-architecture/linked-lists/linked-list-analysis-utilities.md) — Detects if a linked list is palindromic by reversing half of the list and comparing values. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/palindrome_list_test.go))
- [Linked List Reordering](https://awesome-repositories.com/f/software-engineering-architecture/linked-lists/linked-list-sorting-algorithms/linked-list-reordering.md) — Rearranges a singly linked list by alternately inserting nodes from the second half into the first. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/reorder_list_test.go))
- [Linked List Reversals](https://awesome-repositories.com/f/software-engineering-architecture/linked-lists/linked-list-sorting-algorithms/linked-list-reversals.md) — Implements in-place reversal of linked list elements by redirecting next pointers. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/reverse_linked_list_test.go))
- [Middle Node Identification](https://awesome-repositories.com/f/software-engineering-architecture/linked-lists/linked-list-sorting-algorithms/linked-list-reversals/middle-node-identification.md) — Implements a slow and fast pointer strategy to identify the middle node of a singly-linked list. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/middle_list_test.go))
- [Linked List Mid-Node Deletions](https://awesome-repositories.com/f/software-engineering-architecture/linked-lists/node-removal-techniques/doubly-linked-list-removals/linked-list-mid-node-deletions.md) — Provides a method to delete a node from a singly-linked list by copying the successor's value. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/delete_node_test.go))
- [Permutation Generation Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/permutation-generation-algorithms.md) — Implements algorithms for generating all possible orderings of a sequence. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/spermutations_test.go))
- [Bubble Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/bubble-sorts.md) — Implements the classic bubble sort algorithm for ordering elements in an array. ([source](https://github.com/hoanhan101/algo/blob/master/lab/bubble_sort_test.go))
- [Frequency-Based Sorting Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/counting-sorts/sorted-value-frequency-counting/frequency-based-sorting-algorithms.md) — Implements sorting of integers based on their frequency of occurrence. ([source](https://github.com/hoanhan101/algo/blob/master/lab/counting_sort_test.go))
- [Heap Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/heap-sorts.md) — Implements the heapsort algorithm using a max heap to order integers. ([source](https://github.com/hoanhan101/algo/blob/master/lab/heapsort_test.go))
- [Insertion Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/insertion-sorts.md) — Implements the insertion sort algorithm for organizing elements of an unsorted array. ([source](https://github.com/hoanhan101/algo/blob/master/lab/insertion_sort_test.go))
- [Missing Number Identification](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/linear-time-integer-sorts/cyclic-sorts/missing-number-identification.md) — Uses cyclic sort to identify both a duplicate and a missing number within a numeric sequence. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/corrupt_pair_test.go))
- [Merge Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/merge-sorts.md) — Implements the merge sort algorithm using recursive division and merging. ([source](https://github.com/hoanhan101/algo/blob/master/lab/merge_sort_test.go))
- [Interval Merging Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/merge-sorts/interval-merging-algorithms.md) — Provides logic to insert a new interval and merge overlapping segments in a sorted list. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/insert_interval_test.go))
- [Sorted Array Merging](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/sorted-array-merging.md) — Combines two pre-sorted integer arrays into a single sorted array using a two-pointer approach. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/merge_sorted_arrays_test.go))
- [Range-Based Sorting](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/sorted-array-searchers/range-based-sorting.md) — Implements integer sorting in descending order using frequency arrays based on known value ranges. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/top_scores_test.go))
- [Squared-Value Sorting](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/sorted-array-searchers/squared-value-sorting.md) — Implements a two-pointer approach to generate a sorted array of squared values from an input list. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/square_sorted_array_test.go))
- [String Permutation Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-permutation-algorithms.md) — Implements logic to check if a target string contains a permutation of a pattern via a sliding window. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/permutation_string_test.go))
- [Permutation Generators](https://awesome-repositories.com/f/software-engineering-architecture/string-permutation-algorithms/permutation-generators.md) — Implements a recursive character insertion approach to generate all possible rearrangements of a string. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/recursive_string_permutation_test.go))
- [Anagram Substring Identifiers](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/substring-counting/anagram-substring-identifiers.md) — Provides an implementation to locate all occurrences of a pattern's anagrams within a string using a sliding window. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/string_anagrams_test.go))
- [Distinct Character Substring Analyzers](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/substring-counting/longest-substring-identification/distinct-character-substring-analyzers.md) — Calculates the length of the longest substring with k unique characters using a sliding window. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/longest_substring_k_distinct_test.go))
- [Homogeneous Substring Identifiers](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/substring-counting/longest-substring-identification/homogeneous-substring-identifiers.md) — Calculates the maximum length of a substring with identical characters after limited replacements. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/longest_substring_k_replacement_test.go))
- [Longest Substring Without Repeats Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/substring-counting/longest-substring-identification/longest-substring-without-repeats-algorithms.md) — Implements algorithms for finding the longest contiguous substring with all unique characters using sliding window techniques. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/no_repeat_substring_test.go))
- [Tree Path Sum Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/tree-path-sum-algorithms.md) — Calculates the total sum of all root-to-leaf paths in a binary tree using depth-first search. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/sum_path_test.go))
- [Reverse Level-Order Traversals](https://awesome-repositories.com/f/software-engineering-architecture/tree-traversal-algorithms/reverse-level-order-traversals.md) — Groups binary tree nodes by level and returns them from the deepest leaf back to the root. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/reverse_level_order_traversal_test.go))
- [Cycle Detection](https://awesome-repositories.com/f/software-engineering-architecture/two-pointer-strategies/cycle-detection.md) — Provides cycle detection for singly-linked lists using a two-pointer fast and slow approach. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/linked_list_cycle_test.go))

### Data & Databases

- [Least Recently Used Caches](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/caching-performance/caching/least-recently-used-caches.md) — Implements a cache that evicts the least recently used items using a hashmap and doubly linked list. ([source](https://github.com/hoanhan101/algo/blob/master/lab/lru_test.go))
- [Graph Coloring Algorithms](https://awesome-repositories.com/f/data-databases/graph-computing-systems/graph-theory/graph-libraries/graph-coloring-algorithms.md) — Assigns colors to nodes in an undirected graph to ensure no two adjacent nodes share a color. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/graph_coloring_test.go))
- [Three-Way Partitioning](https://awesome-repositories.com/f/data-databases/partitioning-algorithms/efficient-array-partitioning/three-way-partitioning.md) — Organizes arrays containing three distinct values into sorted order using three-way partitioning. ([source](https://github.com/hoanhan101/algo/blob/master/gtci/dutch_flag_test.go))
- [Unique Integer Identification](https://awesome-repositories.com/f/data-databases/unique-integer-identification.md) — Identifies an integer appearing an odd number of times using bitwise XOR operations. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/stolen_breakfast_drone_test.go))
- [Frequency Tracking](https://awesome-repositories.com/f/data-databases/unique-value-counting/frequency-tracking.md) — Maps unique keys to their occurrence counts to identify anagrams, unique integers, or value distributions.

### Programming Languages & Runtimes

- [Go Libraries](https://awesome-repositories.com/f/programming-languages-runtimes/go-libraries.md) — A collection of solved coding interview problems and fundamental data structures implemented in Go.
- [Kth Largest BST Searches](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/hierarchical-tree-structures/binary-search-trees/kth-order-statistics/kth-largest-bst-searches.md) — Identifies the second highest value in a binary search tree by evaluating the rightmost nodes. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/2nd_largest_item_bst_test.go))
- [Tree Validation](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/hierarchical-tree-structures/binary-search-trees/tree-validation.md) — Verifies that a binary tree maintains its structural invariants by checking node bounds. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/binary_search_tree_test.go))
- [Superbalanced Tree Verification](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/hierarchical-tree-structures/binary-search-trees/tree-validation/superbalanced-tree-verification.md) — Determines if a binary tree is superbalanced by checking that leaf depths differ by no more than one. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/balanced_binary_tree_test.go))
- [String Reversal Operations](https://awesome-repositories.com/f/programming-languages-runtimes/string-manipulation/string-reversal-operations.md) — Provides operations for reversing the order of characters in a string, modifying the variable in place. ([source](https://github.com/hoanhan101/algo/blob/master/interviewcake/reverse_string_test.go))