LeetCode Swift | Awesome Repository

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.

LeetCode-Swift is a collection of algorithm solutions written in Swift, designed for coding interview preparation. Each solution is implemented as a self-contained function with no external dependencies, making it easy to run and test. The repository organizes solutions by topic and company, and every file includes time and space complexity annotations, allowing quick evaluation of algorithmic efficiency.

What sets this repository apart is its flat file structure and the way solutions are tagged with the companies that asked them in interviews, enabling targeted practice. All code resides in a single directory without additional packages or modules, simplifying navigation and compilation. The solutions cover fundamental data structures and algorithms, from array and string manipulation to linked list operations, dynamic programming, tree algorithms, and more.

The collection spans classic problem categories including array and string algorithms, linked list manipulations, binary tree traversals and reconstructions, dynamic programming optimizations, stack-based expression evaluation, and mathematical computations. It also includes implementations of common data structures such as an LRU cache. The repository is distributed as a Swift package, allowing others to add it as a dependency and explore the solutions.

Features