hoanhan101/algo

Features

• Interview-Focused Problem Sets - A reference of over 100 common algorithmic challenges and their solutions for technical interview preparation.
• Algorithmic Reference Implementations - Providing coded examples of standard sorting, searching, and graph traversal techniques for use as a technical guide.
• Algorithmic Patterns - Applying specific strategies such as sliding windows, two pointers, and dynamic programming to solve complex computational tasks.
• Go Data Structure Implementations - Implementing fundamental organization patterns like linked lists, binary trees, and heaps using the Go programming language.
• Data Structure Implementations - Implementations of core computer science structures including linked lists, binary trees, heaps, and hash tables in Go.
• Dynamic Programming - Breaks complex problems into smaller subproblems and stores their results to avoid redundant recursive calculations.
• Heaps - Utilizes max or min heaps to maintain sorted access to the most extreme elements in a dataset.
• Pointer Manipulations - Rearranges data by updating node references in place to reverse sequences or reorder elements.
• Sliding Window Patterns - Maintains a dynamic range of elements to compute sums or unique counts without re-scanning the entire input.
• Cyclic Sorts - Implements cyclic sort patterns to place elements at target indices for identifying missing or duplicate values.
• Two-Pointer Strategies - Uses multiple indices moving at different speeds or directions to find targets or detect cycles in linear time.
• Least Recently Used Caches - Implements a cache that evicts the least recently used items using a hashmap and doubly linked list.
• Graph Coloring Algorithms - Assigns colors to nodes in an undirected graph to ensure no two adjacent nodes share a color.
• Three-Way Partitioning - Organizes arrays containing three distinct values into sorted order using three-way partitioning.
• Unique Integer Identification - Identifies an integer appearing an odd number of times using bitwise XOR operations.
• Frequency Tracking - Maps unique keys to their occurrence counts to identify anagrams, unique integers, or value distributions.
• Bracket Validation Algorithms - Implements algorithms to verify correct pairing and ordering of brackets in strings using stack-based parsing.
• Depth Calculations - Calculates the maximum distance from the root to a leaf in a binary tree.
• Minimum - Finds the shortest path from the root to the nearest leaf using level-order traversal.
• Level-Order Traversals - Extracts binary tree values level by level and organizes them into separate sub-arrays.
• Level Average Calculations - Computes the average value of nodes at each depth using level-order traversal.
• Successor Identifications - Locates the node immediately following a target node in a binary tree's level-order sequence.
• Balance Verification - Determines if a binary tree is height-balanced by calculating the depth difference between subtrees.
• In-Place Word Reversal Algorithms - Rearranges characters representing words into the correct sequence by performing a global and individual reverse in place.
• Nesting Level Analyzers - Locates the closing parenthesis corresponding to an opening one by tracking the nesting level.
• Number Property Algorithms - Determines if a number reaches one by repeatedly replacing it with the sum of its squared digits.
• Stack-Based Queues - Simulates first-in-first-out behavior by managing two stacks to handle enqueuing and dequeuing operations.
• Zigzag Traversals - Iterates through a binary tree while alternating the direction of node collection at each depth.
• Technical Interview Preparation - Solving a curated set of common coding challenges in Go to practice algorithmic thinking and problem solving.
• Go Libraries - A collection of solved coding interview problems and fundamental data structures implemented in Go.
• Kth Largest BST Searches - Identifies the second highest value in a binary search tree by evaluating the rightmost nodes.
• Tree Validation - Verifies that a binary tree maintains its structural invariants by checking node bounds.
• Superbalanced Tree Verification - Determines if a binary tree is superbalanced by checking that leaf depths differ by no more than one.
• String Reversal Operations - Provides operations for reversing the order of characters in a string, modifying the variable in place.
• Array Product Transformations - Computes a list where each index contains the product of all other elements without using division.
• Binary Sequence Optimizers - Calculates the longest contiguous sequence of ones possible by replacing a limited number of zeros.
• Combinatorial Product Algorithms - Implements a greedy tracking approach to find the maximum product of three integers in a list.
• Maximum-Tracking Stacks - Returns the largest element in a stack in constant time using a secondary stack of maximums.
• Greedy Sequence Optimizers - Determines the highest gain from buying and selling a stock using a greedy linear scan.
• Cycle Start Locators - Implements logic to identify the exact node where a cycle begins within a linked list.
• Palindrome Permutation Validators - Implements algorithms that check if a string can be rearranged into a palindrome by counting character frequencies.
• Sequence Calculators - Computes the nth Fibonacci number using memoization or iterative approaches to optimize performance.
• Subset Generation - Provides algorithms for computing all possible unique subsets of a given set.
• Unique Subset Generation - Implements logic for generating all possible subsets of a collection while preventing duplicate subsets.
• Sliding Window Averaging - Computes the average of all fixed-size contiguous subarrays using a sliding window technique.
• Rotated Sorted Array Search - Identifies the rotation point of a sorted list of words using binary search.
• Sorted Array Pair Sum Algorithms - Identifies two indices in a sorted array that sum to a target value using two pointers.
• Distinct Element Subarray Counting - Implements sliding window algorithms for counting subarrays containing a limited number of unique elements.
• Maximum Subarray Sums - Provides algorithms for finding the contiguous subarray with the largest total sum.
• Shortest Subarray Sum Locators - Calculates the shortest contiguous subarray whose elements sum to a target value using a dynamic sliding window.
• Knapsack Problem Solving - Calculates the maximum value from items with specific weights without exceeding a limit using dynamic programming.
• Two-Sum Solvers - Determines if two distinct elements in a list add up to a target value using a hashmap for constant-time lookups.
• Combination Sum Algorithms - Computes the total ways to reach a target sum using specific coin denominations via dynamic programming.
• Subset Partitioning - Determines if a collection of numbers can be split into two subsets with equal sums using dynamic programming.
• Word Frequency Counters - Calculates the frequency of each word in a sentence by tracking counts within a hashmap.
• Median Tracking - Tracks a flow of numbers using dual heaps to retrieve the current median in constant time.
• Collection Shuffling - Implements algorithms for randomly rearranging the order of elements within a contiguous memory buffer.
• Duplicate Detection in Arrays - Identifies repeated integers in an array using a swap-to-index strategy.
• Unique Element Filtering - Implements algorithms for removing all duplicate elements from a sorted array to keep only unique values.
• Interval Overlap Detection - Provides algorithms to detect overlapping time intervals by sorting and comparing boundaries.
• Intersection Identifications - Identifies specific overlapping segments between two sorted lists of intervals.
• Linked List Node Retrieval Algorithms - Implements algorithms for locating nodes at specific positions, such as the kth to last element, in linked lists.
• Linked List Analysis Utilities - Detects if a linked list is palindromic by reversing half of the list and comparing values.
• Linked List Reordering - Rearranges a singly linked list by alternately inserting nodes from the second half into the first.
• Linked List Reversals - Implements in-place reversal of linked list elements by redirecting next pointers.
• Middle Node Identification - Implements a slow and fast pointer strategy to identify the middle node of a singly-linked list.
• Linked List Mid-Node Deletions - Provides a method to delete a node from a singly-linked list by copying the successor's value.
• Permutation Generation Algorithms - Implements algorithms for generating all possible orderings of a sequence.
• Bubble Sorts - Implements the classic bubble sort algorithm for ordering elements in an array.
• Frequency-Based Sorting Algorithms - Implements sorting of integers based on their frequency of occurrence.
• Heap Sorts - Implements the heapsort algorithm using a max heap to order integers.
• Insertion Sorts - Implements the insertion sort algorithm for organizing elements of an unsorted array.
• Missing Number Identification - Uses cyclic sort to identify both a duplicate and a missing number within a numeric sequence.
• Merge Sorts - Implements the merge sort algorithm using recursive division and merging.
• Interval Merging Algorithms - Provides logic to insert a new interval and merge overlapping segments in a sorted list.
• Sorted Array Merging - Combines two pre-sorted integer arrays into a single sorted array using a two-pointer approach.
• Range-Based Sorting - Implements integer sorting in descending order using frequency arrays based on known value ranges.
• Squared-Value Sorting - Implements a two-pointer approach to generate a sorted array of squared values from an input list.
• String Permutation Algorithms - Implements logic to check if a target string contains a permutation of a pattern via a sliding window.
• Permutation Generators - Implements a recursive character insertion approach to generate all possible rearrangements of a string.
• Anagram Substring Identifiers - Provides an implementation to locate all occurrences of a pattern's anagrams within a string using a sliding window.
• Distinct Character Substring Analyzers - Calculates the length of the longest substring with k unique characters using a sliding window.
• Homogeneous Substring Identifiers - Calculates the maximum length of a substring with identical characters after limited replacements.
• Longest Substring Without Repeats Algorithms - Implements algorithms for finding the longest contiguous substring with all unique characters using sliding window techniques.
• Tree Path Sum Algorithms - Calculates the total sum of all root-to-leaf paths in a binary tree using depth-first search.
• Reverse Level-Order Traversals - Groups binary tree nodes by level and returns them from the deepest leaf back to the root.
• Cycle Detection - Provides cycle detection for singly-linked lists using a two-pointer fast and slow approach.

Star history