Data Structures and Algorithms using Python

You can write idiomatic Python code utilizing built-in collections, standard library modules, and basic classes to structure data effectively.

1. Variables, data types, operators and fast I/O in Python3 hrs
   • sys.stdin.read
   • int precision
   • bitwise operators
   • f-strings
2. Control flow, loops, functions and list comprehensions3 hrs
   • for-else loops
   • lambda functions
   • generator expressions
   • list comprehensions
3. Built-in structures: lists, tuples, dictionaries and sets3 hrs
   • hash table internals
   • tuple immutability
   • set operations
   • list slicing
4. Object-oriented programming: classes and objects3 hrs
   • __init__
   • dunder methods
   • class attributes
   • inheritance
5. A tour of the standard library: collections, heapq, bisect, itertools and functools4 hrs
   • collections.deque
   • heapq module
   • bisect.bisect_left
   • itertools.permutations

Hands-on project: Build a command-line inventory management script using custom classes, dictionaries, and defaultdict to track stock levels, with an automated test suite written in pytest.

You can rigorously evaluate the time and space complexity of any iterative or recursive Python algorithm using asymptotic notation.

1. Why complexity matters in coding interviews2 hrs
   • hardware constraints
   • scalability limits
   • time-space trade-offs
   • interview expectations
2. Big-O, Big-Theta and Big-Omega notation2 hrs
   • upper bounds
   • tight bounds
   • dominant terms
   • constant factors
3. Best, average and worst case analysis2 hrs
   • input distributions
   • amortized analysis
   • quickstart pivot cases
   • worst-case scenarios
4. Analyzing loops and recursion (and Python's recursion limit)2 hrs
   • sys.setrecursionlimit
   • recursion trees
   • master theorem
   • call stack overhead
5. Space complexity, in-place algorithms and Python performance notes2 hrs
   • auxiliary space
   • garbage collection
   • reference counting
   • in-place mutation

Hands-on project: Benchmark sorting algorithms and recursive memoization approaches across various input sizes using the timeit module, plotting execution times.

You can solve linear data arrangement problems using two-pointer, sliding window, and prefix sum patterns in optimal linear time.

1. Python lists as dynamic arrays: slicing and traversal3 hrs
   • over-allocation
   • amortized append
   • memory layout
   • slicing semantics
2. The two-pointer technique3 hrs
   • left and right pointers
   • converging pointers
   • trapping rain water
   • container with most water
3. Sliding window patterns (fixed and variable size)3 hrs
   • window expansion
   • window contraction
   • subarray sum equals k
   • longest substring without repeating characters
4. Prefix sums and difference arrays3 hrs
   • cumulative sum array
   • range query optimization
   • matrix block sum
   • update range operations
5. Kadane's algorithm and the Dutch National Flag problem3 hrs
   • maximum subarray sum
   • three-way partitioning
   • in-place sorting
   • state transitions
6. String methods and common interview string problems3 hrs
   • string immutability
   • KMP prefix table
   • anagram grouping
   • longest palindromic substring

Hands-on project: Implement an API rate limiter using a sliding window log in Python, passing all edge cases for high-frequency requests.

You can apply binary search across complex solution spaces and leverage Python's internal sorting mechanisms for optimal performance.

1. Linear search and binary search3 hrs
   • search space reduction
   • midpoint overflow prevention
   • sorted array invariant
   • lower and upper bound
2. Binary search with the bisect module3 hrs
   • bisect_left
   • bisect_right
   • insert maintaining order
   • custom key mapping
3. Bubble, selection and insertion sort3 hrs
   • stable sorting
   • adaptive sorting
   • in-place swaps
   • quadratic complexity bounds
4. Merge sort and quick sort with complexity analysis3 hrs
   • divide and conquer
   • partition schemes
   • randomized pivots
   • worst-case stack depth
5. Counting sort, radix sort and heap sort3 hrs
   • non-comparison sorting
   • bucket distribution
   • digit extraction
   • heap property maintenance
6. Python's sorted(), Timsort and key functions3 hrs
   • Timsort algorithm
   • galloping mode
   • functools.cmp_to_key
   • stability guarantee

Hands-on project: Build a binary search engine that locates numerical thresholds in large dataset files under millisecond constraints, utilizing the bisect module.

You can design recursive functions and explore combinatorial solution spaces using systematic backtracking and state pruning.

1. Recursion fundamentals, the call stack and sys.setrecursionlimit3 hrs
   • base case design
   • inductive step
   • stack frame allocation
   • recursion depth tracking
2. Subsets, permutations and combinations3 hrs
   • decision tree model
   • duplicate elimination
   • backtrack state reset
   • lexicographic order
3. N-Queens and the Sudoku solver3 hrs
   • board state representation
   • constraint checking
   • diagonal tracking
   • backtracking loop
4. Rat in a maze and word search3 hrs
   • grid traversal
   • visited state marking
   • DFS matrix search
   • path reconstruction
5. Pruning and backtracking optimization3 hrs
   • bounding functions
   • early termination
   • state space reduction
   • memoized choices

Hands-on project: Write a generalized constraint solver for Sudoku puzzles and N-Queens boards that outputs all valid configurations without stack overflow.

You can construct, manipulate, and traverse singly and doubly linked lists while handling pointer references and memory mutations cleanly.

1. Singly, doubly and circular linked lists using object references3 hrs
   • Node class design
   • next and prev pointers
   • sentinel nodes
   • memory reference management
2. Insertion, deletion and traversal3 hrs
   • head insertion
   • tail deletion
   • pointer realignment
   • edge case handling
3. Reversal: iterative and recursive3 hrs
   • three-pointer technique
   • recursive reversal return
   • sublist reversal
   • k-group reversal
4. Fast and slow pointers: cycle detection (Floyd's algorithm)3 hrs
   • tortoise and hare
   • cycle start node location
   • middle element finding
   • palindrome check
5. Merge, sort, palindrome and intersection problems3 hrs
   • merge two sorted lists
   • merge k sorted lists
   • list intersection node
   • reorder list

Hands-on project: Implement an LRU Cache data structure from scratch using a doubly linked list combined with a hash dictionary for O(1) gets andputs.

You can solve structural ordering and window-tracking problems using monotonic stacks and deque-backed queue structures.

1. Stacks with lists and queues with collections.deque (O(1) at both ends)3 hrs
   • list append and pop
   • deque appendleft and popleft
   • amortized time bounds
   • underflow prevention
2. Circular queue and deque patterns3 hrs
   • fixed-size ring buffer
   • head and tail pointers
   • modulo arithmetic
   • sliding window maximum
3. Monotonic stack and monotonic queue3 hrs
   • increasing stack invariant
   • decreasing stack invariant
   • element eviction rule
   • window extrema tracking
4. Next greater element and stock span3 hrs
   • monotonic decrease pattern
   • histogram area calculation
   • daily temperatures
   • span accumulation
5. Expression evaluation and balanced parentheses3 hrs
   • infix to postfix conversion
   • operator precedence
   • bracket matching map
   • syntax validation

Hands-on project: Build a postfix expression evaluator and syntax validator that processes complex mathematical formulas using stack data structures.

You can traverse, balance, and query hierarchical data structures including binary trees, binary search trees, and prefix tries.

1. Binary trees and traversals (in / pre / post / level order)3 hrs
   • recursive traversal
   • iterative traversal with stack
   • breadth-first traversal
   • zig-zag level order
2. Height, diameter, views and lowest common ancestor (LCA)3 hrs
   • tree depth calculation
   • diameter path tracking
   • left and right views
   • binary lifting LCA
3. Binary Search Trees: insert, delete and search3 hrs
   • BST property invariant
   • node deletion cases
   • successor and predecessor
   • validate BST
4. Balanced trees: AVL and Red-Black overview (and sortedcontainers)3 hrs
   • tree rotations
   • balance factor tracking
   • sortedcontainers.SortedList
   • self-balancing invariants
5. Tries (prefix trees)3 hrs
   • TrieNode implementation
   • word insertion and search
   • prefix matching
   • word search II
6. Segment Trees and Fenwick Trees (BIT)4 hrs
   • range sum queries
   • point updates
   • lazy propagation
   • binary indexed tree operations

Hands-on project: Build an autocomplete suggestion system backed by a Trie data structure, capable of returning top-5 matching prefixes in real time.

You can manage priority queues using the heapq module and solve frequency and lookup challenges using Python dictionaries and sets.

1. The heapq 'module': min-heaps and max-heaps (via negation)3 hrs
   • heappush and heappop
   • heapify array
   • max-heap trick via tuple negation
   • priority queue invariant
2. Top-K problems and the median in a data stream3 hrs
   • k frequent elements
   • kth largest element
   • two-heap balance strategy
   • streaming data aggregation
3. Hash tables: dictionaries and sets3 hrs
   • hash function mechanics
   • collision resolution
   • load factor resizing
   • time complexity guarantees
4. Counter and defaultdict patterns3 hrs
   • collections.Counter
   • collections.defaultdict
   • frequency counting
   • grouping anagrams
5. Frequency counting and subarray-sum problems3 hrs
   • hash map prefix sums
   • longest consecutive sequence
   • two sum variations
   • subarray sum divisible by k

Hands-on project: Develop a real-time data stream median calculator using two balanced heaps to process continuous numerical updates efficiently.

You can model complex network relationships and compute shortest paths, topological sorts, and minimum spanning trees in Python.

1. Graph representations with dict and defaultdict adjacency lists3 hrs
   • adjacency list representation
   • adjacency matrix
   • directed vs undirected graphs
   • weighted edges
2. Breadth-First Search (BFS) with deque and Depth-First Search (DFS)3 hrs
   • queue-based BFS traversal
   • stack-based DFS traversal
   • visited set tracking
   • connected components
3. Connected components and cycle detection3 hrs
   • directed cycle detection
   • undirected cycle detection
   • number of provinces
   • bipartite graph check
4. Topological sorting (Kahn's algorithm and DFS)3 hrs
   • dependency graphs
   • in-degree calculation
   • course schedule solver
   • cycle detection in DAGs
5. Shortest paths: Dijkstra, Bellman-Ford and Floyd-Warshall4 hrs
   • priority queue Dijkstra
   • negative edge weights
   • all-pairs shortest path
   • path reconstruction
6. Minimum Spanning Tree: Kruskal and Prim3 hrs
   • edge sorting
   • greedy edge selection
   • minimum spanning forest
   • network design
7. Union-Find (Disjoint Set Union)3 hrs
   • path compression
   • union by rank
   • connected components count
   • redundant connection

Hands-on project: Build a route planning application that computes optimal driving directions across a road network using Dijkstra's algorithm and adjacency lists.

You can break down complex optimization challenges into overlapping subproblems and solve them using memoization and tabulation.

1. DP fundamentals: memoization vs tabulation3 hrs
   • overlapping subproblems
   • optimal substructure
   • top-down recursion
   • bottom-up iteration
2. Effortless memoization with functools.lru_cache and @cache3 hrs
   • @functools.cache
   • lru_cache maxsize
   • hashable arguments requirement
   • cache clearing and info
3. 1D DP: climbing stairs, house robber and Fibonacci3 hrs
   • state transition relation
   • space optimization to O(1)
   • fibonacci sequence variants
   • house robber permutations
4. Knapsack patterns: 0/1 and unbounded3 hrs
   • 0/1 knapsack table
   • unbounded knapsack
   • coin change problem
   • subset sum partition
5. Subsequence DP: LIS, LCS and edit distance3 hrs
   • longest increasing subsequence
   • longest common subsequence
   • levenshtein distance
   • string alignment
6. DP on grids, trees and bitmask DP4 hrs
   • unique paths in grid
   • minimum path sum
   • house robber III on trees
   • traveling salesperson state

Hands-on project: Build an investment portfolio optimizer that solves the 0/1 Knapsack problem with budget constraints using bottom-up tabulation.

You can construct optimal greedy choices and manipulate bits using Python's arbitrary-precision integer representations.

1. Greedy strategy and the exchange argument2 hrs
   • greedy choice property
   • proof by exchange
   • optimal substructure proof
   • when greedy fails
2. Activity selection, interval scheduling and job sequencing2 hrs
   • meeting rooms scheduler
   • non-overlapping intervals
   • minimum number of arrows
   • greedy scheduling
3. Bit manipulation with Python's arbitrary-precision integers2 hrs
   • bitwise AND, OR, XOR
   • bit shifting operations
   • single number problems
   • power of two checks
4. Number theory: GCD, Sieve of Eratosthenes and modular arithmetic2 hrs
   • Euclidean algorithm
   • prime factorization
   • Sieve of Eratosthenes
   • modular exponentiation
5. Huffman coding and fractional knapsack2 hrs
   • priority queue greedy
   • prefix codes generation
   • fractional value sorting
   • optimal compression

Hands-on project: Implement an interval scheduling scheduler and a custom bitwise compression utility for sparse boolean arrays.

You can successfully clear technical coding interviews and present production-ready Python problem-solving portfolios.

1. Company-wise problem patterns (FAANG, product and service firms)3 hrs
   • pattern mapping
   • frequency analysis
   • interview rubric standards
   • time management strategies
2. Using Python effectively in coding interviews3 hrs
   • builtin shortcuts
   • clean code style
   • verbalizing thought process
   • edge case testing
3. Live mock coding interviews with detailed feedback4 hrs
   • peer coding rounds
   • interviewer communication
   • handling hints
   • performance critique
4. Resume, LeetCode and GitHub profile building3 hrs
   • ATS-friendly resume layout
   • GitHub repo organization
   • LeetCode stats curation
   • project highlighting
5. HR and behavioural interview preparation3 hrs
   • STAR method responses
   • culture fit alignment
   • salary negotiation
   • career goal articulation

Hands-on project: Deliver a fully tested, packaged algorithmic solver library in Python with GitHub Actions CI, complete with mock interview evaluations.