Data Structures & Algorithms for Career Switch

Create, index, and modify arrays in your chosen language while analyzing time complexity of basic access patterns.

Manipulate string immutability, slicing, and concatenation to understand performance implications for text processing.

Solve palindrome checks and pair-sum problems by moving left and right indices toward each other in linear time.

Calculate maximum subarray sums of fixed length using a rolling window to avoid nested loop overhead.

Find longest substrings meeting dynamic constraints by expanding and contracting window boundaries conditionally.

Precompute cumulative sums to answer range-sum queries in constant time for static datasets.

Count element occurrences and detect duplicates using hash maps for O(1) average lookup performance.

Reverse arrays and string character arrays using constant extra space by swapping symmetric positions.

Rearrange array elements around a pivot value using Dutch National Flag partitioning logic.

Navigate 2D grids in spiral, diagonal, and layer-by-layer orders while maintaining boundary conditions.

Implement Knuth-Morris-Pratt prefix table construction to achieve linear-time substring search.

Apply run-length encoding and coordinate compression to reduce storage for repetitive or sparse data.

Sort and merge overlapping time intervals to produce a minimal set of non-overlapping ranges.

Construct a CLI tool that ingests a text file and reports word frequencies, longest unique substring, and palindrome counts using optimized array and string algorithms.

Define a Node class with data and next pointer fields to represent a single list element.

Create a LinkedList class with a head reference and size counter for basic list management.

Implement adding nodes to the end of the list while maintaining correct pointer chains.

Implement inserting nodes at the beginning of the list with proper head pointer updates.

Write iterative traversal logic to visit every node for reading or display purposes.

Implement linear search to locate the first node containing a target value.

Insert a new node at a specific zero-based index by relinking predecessor and successor nodes.

Remove the first occurrence of a value by bypassing the target node and handling head deletion.

Remove a node at a given index with boundary checks and pointer updates for adjacent nodes.

Reverse the entire list in place using three-pointer iteration to flip next pointers.

Find the middle node in a single pass using slow and fast pointer advancement.

Determine if the list contains a cycle using Floyd's Tortoise and Hare algorithm.

Combine two sorted linked lists into a new sorted list by splicing existing nodes.

Construct a playlist application using the linked list to add, remove, reorder, and play tracks dynamically.

Explain LIFO behavior and identify real-world scenarios where stack operations apply.

Build a stack class using a dynamic array with push, pop, and peek methods.

Construct a stack using a singly linked list to compare memory trade-offs with array approach.

Implement an algorithm that validates matching brackets in expressions using a stack.

Convert infix arithmetic expressions to postfix notation and evaluate them with a stack.

Describe FIFO behavior and recognize use cases requiring ordered processing.

Create a circular queue using a fixed-size array with enqueue, dequeue, and front operations.

Develop a queue with a singly linked list maintaining head and tail pointers for O(1) operations.

Build a double-ended queue supporting insertion and removal at both front and rear.

Design a stack that returns the minimum element in constant time using auxiliary storage.

Simulate queue behavior using two stack instances to understand structural relationships.

Solve the maximum of all subarrays of size k using a deque for optimal linear time.

Model a CPU task scheduler processing jobs with priorities using queue-based logic.

Build a complete browser history system with back, forward, and visit functionality using dual stacks.

Implement basic hash functions for strings and integers to understand key-to-index mapping and collision inevitability.

Build a direct-address table for small integer key ranges to experience O(1) access without hashing complexity.

Implement a hash table using separate chaining with linked lists to handle collisions dynamically.

Implement linear probing collision resolution and analyze clustering effects on lookup performance.

Implement quadratic probing and double hashing to reduce primary and secondary clustering in open addressing.

Implement automatic resizing with rehashing to maintain load factor thresholds and amortized O(1) operations.

Design hash functions for custom objects by combining field hashes and implementing equality contracts.

Build a HashSet data structure from scratch using open addressing with tombstone deletion handling.

Build a complete HashMap supporting key-value operations, iteration, and entry replacement semantics.

Solve frequency analysis problems using hash maps to count elements, find duplicates, and identify modes.

Apply hash map complement lookup to solve Two Sum and variants in O(n) time versus O(n²) brute force.

Use prefix sums with hash maps to solve subarray sum equals k and maximum length subarray problems.

Group anagrams using sorted strings as hash keys to practice composite key generation and bucket collection.

Build a production-ready LRU cache combining hash map O(1) lookup with doubly linked list O(1) reordering for eviction policy.

Define a binary tree node class with value, left, and right pointers to represent hierarchical data in memory.

Implement depth-first preorder traversal recursively to process root before subtrees for tree cloning and serialization tasks.

Implement depth-first inorder traversal recursively to retrieve nodes in sorted order from binary search trees.

Implement depth-first postorder traversal recursively to process children before parents for tree deletion and height calculation.

Convert recursive preorder to an explicit stack-based implementation to avoid call stack limits on deep trees.

Implement iterative inorder traversal using a stack to simulate the call stack and enable pause-resume iteration.

Implement iterative postorder traversal with a single stack and previous pointer to handle the non-trivial visit order efficiently.

Traverse trees breadth-first using a queue to process nodes level by level for shortest path and minimum depth problems.

Capture depth information during level order traversal to solve level-average and right-side-view problems.

Alternate traversal direction per level using a deque to produce zigzag output for spiral tree printing.

Use preorder traversal with path accumulation to find all root-to-leaf paths matching a target sum.

Apply postorder traversal logic to identify the lowest common ancestor of two nodes in a binary tree.

Combine preorder traversal with null markers to serialize a tree to a string and reconstruct it accurately.

Reconstruct a unique binary tree from preorder and inorder sequences using recursive partitioning and index mapping.

Classify sorting algorithms by stability, memory usage, and time complexity to select the right tool for a given problem.

Implement Bubble Sort with an early-exit optimization and measure its quadratic runtime on sample datasets.

Code Selection Sort to minimize write operations and verify its performance profile against Bubble Sort.

Build Insertion Sort that efficiently handles nearly sorted data and serves as a base for hybrid algorithms.

Implement Shell Sort using the Knuth gap sequence to improve Insertion Sort performance on medium arrays.

Construct a top-down Merge Sort with a shared auxiliary array to achieve stable O(n log n) sorting.

Convert recursive Merge Sort to a bottom-up iterative version to eliminate call-stack overhead.

Implement Lomuto and Hoare partition schemes and compare their swap counts on duplicate-heavy data.

Add median-of-three pivot selection and Insertion Sort cutoff to harden Quick Sort against worst-case inputs.

Build Heap Sort by implementing sift-down heapify and in-place extraction for guaranteed O(n log n) performance.

Implement Counting Sort for integer keys with a known range to achieve linear time sorting.

Compose LSD Radix Sort using Counting Sort as a stable subroutine to sort integers in linear time.

Create an Introsort variant that switches between Quick Sort, Heap Sort, and Insertion Sort based on recursion depth.

Build a benchmarking harness to compare all implemented sorts across random, sorted, reverse, and duplicate datasets.

Implement adjacency list and matrix structures to model real-world networks like social connections or transit maps.

Code recursive and iterative DFS to traverse graphs and detect cycles in dependency graphs.

Implement BFS using a queue to find shortest paths in unweighted networks like friendship degrees.

Benchmark DFS and BFS on memory usage and path optimality for maze solving scenarios.

Identify isolated clusters in undirected graphs using traversal to analyze network fragmentation.

Order tasks with dependencies using Kahn's algorithm to generate valid build sequences.

Detect circular dependencies in directed graphs using DFS colors to prevent deadlock in schedulers.

Check two-colorability with BFS to validate matching constraints in job assignment problems.

Apply BFS on implicit grid graphs to compute minimum moves in puzzle games with obstacles.

Implement priority-queue Dijkstra to find shortest weighted paths in road networks with positive distances.

Integrate heuristic functions with Dijkstra to accelerate pathfinding in game maps and robotics.

Build Prim's algorithm with heaps to design cost-optimal infrastructure networks like cable layouts.

Implement Edmonds-Karp to compute maximum throughput in transportation or bandwidth allocation systems.

Develop a route planner combining A* search and real-time traffic weights for multi-stop delivery optimization.

Identify overlapping subproblems in recursive solutions to recognize when dynamic programming applies.

Implement top-down memoization to optimize recursive Fibonacci and factorial calculations.

Convert memoized recursive solutions into bottom-up iterative approaches using tables.

Solve the climbing stairs problem using both memoization and tabulation to compare approaches.

Apply dynamic programming to maximize robbery profit while avoiding adjacent houses.

Compute minimum coins needed for a target amount using bottom-up tabulation.

Determine the length of the longest strictly increasing subsequence in an array.

Calculate minimum edit operations to convert one string into another using a 2D DP table.

Solve the 0/1 knapsack problem to maximize value within a weight constraint.

Count unique paths in a grid with obstacles using dynamic programming on a 2D matrix.

Determine the number of ways to decode a digit string into letters using DP state transitions.

Find the maximum product subarray by tracking both maximum and minimum products at each step.

Classify unseen problems as suitable for memoization, tabulation, or greedy approaches based on structure.

Solve a timed dynamic programming problem under simulated interview conditions with clean code and explanation.