soapyigu/LeetCode-Swift

Features

• Swift Implementations - Provides algorithm solutions implemented natively in Swift for language-specific learning.
• Topic-Directory Categorization - Organises algorithm solutions into groups by data structure or technique such as arrays, trees, or dynamic programming for focused practice.
• Coding Interview Preparation - Provides a curated collection of Swift algorithm solutions for technical interview practice.
• Data Structures and Algorithms - Ships working Swift implementations of fundamental data structures and algorithms for study.
• Majority Element Detections - Traverses an array while tracking a candidate count to identify the element that appears more than half the time.
• Increasing Subsequence Detection - Finds if an array contains three indices with strictly increasing values using two pointers in linear time.
• Consecutive Sequence Detections - Finds the longest consecutive sequence of integers in an array using a set for linear time complexity.
• Complexity Annotations - Each solution includes time and space complexity comments, allowing quick evaluation of algorithmic efficiency.
• Array Intersection Algorithms - Uses a frequency dictionary to count occurrences in one array, then filters the second array to return elements that appear in both with multiplicity.
• Array Product Algorithms - Calculates the product of all array elements except the current element using left and right multiplication passes.
• Closest Triple Sum Algorithms - Finds the sum of three elements from an array that is closest to a specified target value.
• In-Place Array Manipulations - Shifts array elements by a given offset using three reversals, achieving linear time and constant extra space.
• Linked List Manipulation Utilities - Implements the fundamental linked list reversal operation using iterative pointer adjustment.
• Missing Positive Integer Detections - Finds the smallest positive integer that does not appear in an unsorted array using a set for linear time complexity.
• Anagram Grouping Algorithms - Groups strings into subarrays where each subarray contains words that are anagrams, using sorted strings as dictionary keys.
• Cache Eviction Policies - Implements an LFU cache eviction policy that removes the least frequently requested items.
• Financial Profit Optimizers - Computes the maximum profit from a single buy-sell pair by tracking the lowest price seen so far in one linear pass.
• Set Intersection Analysis - Finds the intersection of two collections by storing elements from one in a set and iterating the other for common elements.
• Bracket Validation Algorithms - Implements stack-based bracket validation for coding interview practice.
• Character Sufficiency Checkers - Ships a routine to check if a target string can be composed from a source string's characters.
• Count-and-Say Sequence Generators - Implements the count-and-say sequence generation algorithm.
• Custom Lexicographic Order Validators - Provides a routine to validate word ordering based on a custom alphabet.
• Depth Calculations - Calculates maximum depth of a binary tree using recursion.
• Diameter Computations - Implements binary tree diameter computation using recursive traversal.
• Inversion Operations - Implements binary tree inversion by swapping children recursively.
• Iterative Traversals - Ships iterative tree traversal implementations using an explicit stack.
• Level-Order Traversals - Implements level-order tree traversal grouping values by depth level.
• Serialization Techniques - Provides binary tree serialization and deserialization using preorder traversal.
• Symmetry Checks - Validates binary tree symmetry through recursive subtree comparison.
• Tree Serialization - Converts binary trees to string representation and back for storage or transmission.
• Stack-Based Minimum Finders - Implements a stack with constant-time minimum value retrieval using an auxiliary stack.
• Balanced Search Trees - Implements construction of height-balanced binary search trees from sorted arrays.
• First Unique Character Detectors - Implements logic to find the first character that appears only once in a string.
• Flip Game Move Generators - Generates all possible move outcomes for the flip game problem.
• In-Place Word Reversal Algorithms - Ships an in-place algorithm to reverse the order of words in a character string.
• Pattern-Word Correspondence Validators - Implements bijection check between a pattern and a list of words.
• String Isomorphism Checkers - Implements character-to-character mapping check for string isomorphism.
• String Number Adders - Implements digit-by-digit addition of integers represented as strings.
• String Vowel Swappers - Ships a two-pointer algorithm to swap vowels in a string.
• Zigzag Traversals - Implements zigzag level-order traversal of binary trees, alternating direction per level.
• Technical Interview Archives - Organizes categorized algorithm solutions to build pattern recognition for technical interviews.
• Text Justification Algorithms - Implements full text justification to produce lines of specified width.
• Tree Reconstruction - Builds binary trees from inorder and postorder traversal arrays.
• IP Address Validation - Provides validation logic for IPv4 and IPv6 address formats.
• Kth Order Statistics - Finds the Kth smallest value in a BST using in-order traversal.
• Recovery Techniques - Implements recovery of a BST with swapped nodes using Morris traversal.
• Minimum Word Distance Calculations - Iterates through an array and updates the minimum distance whenever encountering either word, returning the smallest gap found.
• Missing Interval Detection - Scans a sorted array and identifies numeric intervals missing between a lower and upper bound.
• Palindromic Sequence Analyzers - Implements a palindrome validation algorithm that ignores non-alphanumeric characters and case.
• Palindrome Permutation Validators - Implements frequency-based check for possible palindromic rearrangements.
• Single-Deletion Palindrome Checkers - Implements a two-pointer algorithm to check if a string is a palindrome after at most one deletion.
• Lexicographical Sequence Generators - Computes the next lexicographic permutation of an array in linear time and constant extra space.
• Prefix Calculations - Implements longest common prefix detection across a set of strings.
• Prefix Sum Algorithms - Precomputes a prefix sum matrix to answer sum queries for any rectangular subregion in constant time.
• Subarray Target Sum Locators - Uses a hash map to store cumulative sums and their indices to locate the longest contiguous subarray that sums to a given value.
• Run Length Encoding Implementations - Provides run-length encoding compression for strings.
• Sorted Array Pair Sum Algorithms - Uses two pointers to efficiently find two numbers in a sorted array that sum to a given target and return their positions.
• Abbreviation Validators - Implements validation of abbreviated word forms using digit skip counts.
• Minimum Length Subarray Sums - Uses two pointers to find the smallest contiguous subarray whose sum is at least a given target value.
• Target Sum Pair Search - Traverses an array and uses a dictionary to store complements for linear time and space complexity.
• Triplet Sum Algorithms - Finds all unique triplets in an array summing to zero by sorting and applying a two-pointer technique.
• Duplicate Element Detection - Searches an array for duplicate values within a given index distance using a hash map to track last seen positions.
• Postfix Expression Evaluators - Implements a stack-based evaluator for arithmetic expressions in Reverse Polish Notation.
• Duplicate Limiting in Sorted Arrays - Removes duplicates from a sorted array in-place, allowing each element to appear at most twice, using linear time and constant space.
• Integer Range Compression Algorithms - Traverses a sorted integer array and condenses consecutive runs into range strings for compact display.
• Linked List Analysis Utilities - Implements a palindrome check on a linked list by reversing the first half and comparing halves.
• Halves Interleaving Algorithms - Implements a specific linked list reordering algorithm that splits, reverses, and interleaves halves.
• Index-Based Reordering Algorithms - Implements a linked list reordering algorithm that groups odd-indexed nodes before even-indexed ones.
• Rotation Algorithms - Implements a linked list rotation algorithm that shifts nodes by a given offset.
• Merge Algorithms - Implements a merge algorithm for combining two sorted linked lists into one sorted list.
• Node Removal Techniques - Implements a two-pointer technique to delete the Nth node from the end of a linked list.
• LRU Cache Eviction - Implements an LRU cache using a doubly linked list and hash map for constant-time get and put operations.
• Company-Specific Problem Mappings - Labels solutions with the companies that asked them in interviews, enabling targeted preparation.
• Extremum Tracking Algorithms - Implements a stack with constant-time maximum element retrieval using an auxiliary stack.
• Repetition-Based String Decoders - Implements decoding of strings with repetition numbers, a common interview problem.
• Palindromic Substring Counters - Ships a DP algorithm to count all palindromic substrings in a string.
• Tree Path Sum Algorithms - Implements root-to-leaf path sum collection for binary trees, a classic tree algorithm problem.
• Path Enumerations - Enumerates all root-to-leaf paths in a binary tree.
• In-Order Iterators - Provides an iterative in-order traversal implementation for binary search trees.
• Postorder Traversals - Implements iterative postorder traversal for binary trees.
• Vertical Tree Traversals - Provides vertical order traversal of binary trees, a common interview problem.
• Ternary Expression Evaluators - Implements a stack-based evaluator for ternary conditional expressions using right-to-left traversal.
• Data Persistence - Collection of interview algorithm solutions.

Star 历史