Data Structures and Algorithms in Swift and iOS

Discover arrays as ordered, random-access data structures with constant-time indexing in Swift, and learn their contiguous memory layout, fixed size, and how doubling supports growth behind the scenes.

Learn arrays in Swift by creating and populating them, retrieving values by index, iterating with for-in and enumerated, and adding or removing elements for interview prep.

Learn how to approach interview questions by reading conditions, selecting the right data structure, and solving a binary array problem: find the maximum consecutive ones with a single pass.

Explore a one-pass algorithm to find the majority element in an array. Maintain a single counter to track the candidate, updating when the count reaches zero.

Learn to find all elements appearing more than a third of an array by counting with a dictionary and returning those with counts over n/3, with interview-ready complexity insights.

Explore how to compute the unique intersection of two arrays using sets, emphasizing distinct values, order independence, and efficient lookups within Swift and iOS data structures.

Explore finding the intersection of two arrays with duplicates by counting frequencies with a dictionary, then iterating the second array to build the result in any order.

Identify duplicates in an array by scanning elements and using a dictionary to track seen values in one pass, returning true if a duplicate is found.

Learn to detect duplicates within a distance in an array using a last-seen index map, compute the gap and minimum distance, and return true if distance is within k.

Master how to remove duplicates from a sorted array in place using a two-pointer method with O(1) extra space, returning the length of the unique prefix.

Apply a two-pointer in-place solution to remove duplicates from a sorted array, preserving at most two occurrences and overwriting with the allowed elements.

Move zeros to the end of the array in place by using a pointer to shift non-zero values forward, preserving their order, and filling the remainder with zeros.

Move non-target elements to the front using a two-pointer in place algorithm, removing all instances of a given value with only one extra memory and returning the new length.

Master string manipulation and interview question techniques by working through a fizzbuzz example that checks multiples of three and five, printing fizz, buzz, or fizzbuzz when appropriate.

Explore the palindrome interview question using a two-pointer approach on a string, scanning from both ends to verify palindrome status, with alphanumeric filtering and case normalization.

Solve the first unique character problem by using a dictionary to track character appearances in a string, performing two passes to return the index or -1 if none.

Explore the at most one deletion palindrome problem using a two-pointer approach with a removal flag in Swift. See how skipping one character can yield a palindrome.

Explore the count and say interview problem, using integer counting and iterative input transformation to generate successive sequences, with emphasis on an efficient looping algorithm and minimal string manipulation.

Explore finding the first index of a needle in a haystack by looping the haystack and performing a nested comparison with the needle; return -1 if not found.

Explore linked lists as dynamic, noncontiguous data structures built from nodes connected by pointers. Learn how head, tail, and insertions or deletions enable efficient memory use and sequential traversal.

Learn how to insert a node into a linked list, at the beginning or end, using head and next pointers, including empty list handling and the linear time end insertion.

Learn to search for a key in a linked list and delete nodes by updating head, current, and previous pointers, returning nil when not found, in Swift.

Learn to reverse a linked list in one pass without extra memory, an interview question solution using current, next, and previous pointers to flip links and update the head.

Merge two sorted singly linked lists by iterating with two pointers, comparing nodes, and building a new sorted list with a dummy head; connect the remainder after one list ends.

Learn how to detect a cycle in a singly linked list using slow and fast pointers, recognize pointer meetings, and determine whether a loop exists.

Detect a cycle in a singly linked list with fast and slow pointers, then compute cycle length by advancing the fast pointer through loop until it returns to meeting point.

Detect a cycle in a singly linked list and find the start of the cycle using two pointers, computing the cycle length.

Learn how to find the start of a cycle in a singly linked list without counting the cycle length, using fast and slow pointers and resetting to head.

Learn to add two numbers stored as reversed linked lists, using a carry-aware algorithm that traverses nodes, computes digit sums with mod 10, and builds the result list.

Learn how stacks implement last in, first out with push, pop, and top operations, using array-based and linked-list approaches, and see interview-ready patterns.

Explore an array-based stack implementation in Swift, with push, pop, and peek operations, using an array backing to achieve last-in, first-out behavior and isEmpty checks.

Implement a linked-list based stack with push, pop, peek, and is empty operations, using a head pointer and node links to manage elements and track stack length.

Implement a minimum stack on top of a standard stack, supporting push, pop, top, and get minimum in constant time by maintaining a secondary min-stack that tracks the current minimum.

Master the balance of parentheses in strings using a stack to validate matching types, including round, square, and curly brackets, ensuring correct order and proper closing.

Learn to compute the longest valid parentheses substring using a stack of indices and a sentinel to measure distances between matched parentheses.

Learn to evaluate reverse Polish notation with a stack-based algorithm that processes integers and operators (+, -, *, /) to produce the correct result.

Learn to simplify an absolute Unix path into a canonical form using a stack: tokenize by slash, handle ., .., and extra slashes, and produce a leading slash separated path.

remove k digits from a non-negative number given as a string to form the smallest possible number, using a stack-based approach in swift and handling leading zeros with clear examples.

remove k digits from a number represented as a string to form the smallest possible value, without using a stack, by applying forward index comparisons and iterative removal.

Explore queues as a first in, first out linear data structure, with enqueue, dequeue, peak, and clear operations, and compare them to stacks while previewing an LRU cache.

Demonstrate building a queue using an array as the backing store, implementing enqueue, dequeue, and clear operations, and showing fifo behavior.

Build a queue using a linked list in Swift by creating a node with data and next, and managing head and tail with length tracking.

Explore the least recently used (LRU) cache design using a dictionary for fast lookups and a doubly linked list to track recency, with an eviction policy for fixed memory.

Demonstrates implementing an LRU cache in Swift, combining a generic doubly linked list and a hash table to manage capacity, move accessed nodes to the head, and evict tails.

Learn to build a generic stack in Swift by defining a generic node, implementing push and pop, and verifying last-in, first-out behavior with a sample run.

Explore building a queue from stacks, using two stacks to preserve fifo order with an expensive enqueue, and analyze the resulting dequeue performance.

Learn to implement a queue using two stacks to preserve insertion order, performing an expensive dequeue by transferring elements between stack one and stack two.