Data Structures and Algorithms using C & C++

You can write robust C and C++ programs utilizing core data types, memory structures, and custom classes for foundational software projects.

1. Variables, data types, operators and I/O in C and C++90 min
   • int, float, char, and double primitives
   • std::cin and std::cout streams
   • bitwise and arithmetic operators
2. Control flow, loops and functions120 min
   • if-else and switch-case branching
   • for, while, and do-while loops
   • function signatures, prototypes, and pass-by-reference
3. Arrays, C-style strings and std::string90 min
   • multidimensional array layouts
   • null-terminated char arrays
   • std::string methods and manipulation
4. Structures, unions and enumerations90 min
   • struct padding and memory alignment
   • union memory sharing
   • enum class scoping
5. Introduction to C++ classes and object-oriented programming120 min
   • public, private, and protected visibility
   • constructors and destructors
   • member functions and 'this' pointer

Hands-on project: Build a command-line student records manager using custom structs, file I/O, and class encapsulation with zero memory leaks.

You can manage memory safely using raw pointers, RAII patterns, and high-performance C++ Standard Template Library containers.

1. Pointers, pointer arithmetic and double pointers120 min
   • memory address dereferencing
   • pointer arithmetic on arrays
   • double pointers and pointer-to-pointer parameters
2. Dynamic memory: malloc / calloc / realloc / free and new / delete120 min
   • heap memory allocation functions
   • new and delete operator overloading
   • initialization differences between C and C++ allocation
3. Memory leaks, dangling pointers and RAII basics90 min
   • Valgrind memory profiling
   • dangling pointer bugs
   • Resource Acquisition Is Initialization (RAII)
4. References, function pointers and templates90 min
   • lvalue references vs pointers
   • function pointers for callbacks
   • class and function templates
5. The C++ STL: vector, list, stack, queue, map, set, priority_queue and algorithms150 min
   • std::vector capacity and reallocation overhead
   • std::unordered_map hashing mechanics
   • std::priority_queue heap implementation

Hands-on project: Implement a custom dynamic array container that mimics std::vector with automatic capacity resizing and manual pointer cleanup.

You can evaluate the asymptotic performance of any recursive or iterative algorithm using rigorous Big-O, Omega, and Theta notation.

1. Why complexity matters in coding interviews60 min
   • hardware constraints and execution limits
   • scalability bottlenecks
   • worst-case time bounds
2. Big-O, Big-Theta and Big-Omega notation90 min
   • mathematical definitions of asymptotic bounds
   • upper and lower growth rates
   • constant factor elimination
3. Best, average and worst case analysis60 min
   • input distributions
   • amortized analysis concepts
   • worst-case scenarios
4. Analyzing loops, recursion and recurrence relations90 min
   • Master Theorem for recurrences
   • recursion tree method
   • nested loop counting
5. Space complexity and in-place algorithms60 min
   • auxiliary memory usage
   • call stack frame memory
   • in-place transformation definitions

Hands-on project: Benchmark iterative and recursive Fibonacci implementations with a custom high-resolution timer utility and graph the execution times.

You can solve complex linear scan problems efficiently using sliding windows, two pointers, prefix sums, and Kadane's algorithm.

1. Array traversal, rotation and in-place operations90 min
   • array cyclic rotation
   • in-place matrix transposition
   • reversal algorithm for shifts
2. The two-pointer technique90 min
   • opposite-direction pointers
   • same-direction slow and fast pointers
   • sorted array pair summation
3. Sliding window patterns (fixed and variable size)120 min
   • fixed-size window maximum sum
   • variable-size window smallest subarray
   • character frequency tracking
4. Prefix sums and difference arrays90 min
   • range sum queries in O(1)
   • difference array range updates
   • 2D prefix sum matrices
5. Kadane's algorithm and the Dutch National Flag problem90 min
   • maximum subarray sum state transitions
   • three-way partitioning
   • in-place color sorting
6. String algorithms with C-strings and std::string90 min
   • anagram and palindrome verification
   • string tokenizer implementation
   • lexicographical comparison

Hands-on project: Code a substring search and pattern matcher using sliding window bounds and verify its correctness against edge test cases.

You can implement custom sorting algorithms, apply binary search on answer spaces, and leverage C++ sorting comparators.

1. Linear search and binary search60 min
   • iterative and recursive binary search
   • lower_bound and upper_bound logic
   • search space reduction
2. Binary search on the answer90 min
   • monotonic predicate function design
   • allocation and capacity optimization problems
   • precision floating-point binary search
3. Bubble, selection and insertion sort90 min
   • in-place quadratic sorting mechanics
   • adaptive sorting behavior
   • stability in sorting
4. Merge sort and quick sort with complexity analysis120 min
   • divide-and-conquer merge step
   • pivot selection strategies in quick sort
   • worst-case partition avoidance
5. Counting sort, radix sort and heap sort90 min
   • non-comparison sorting limits
   • digit-by-digit bucket distribution
   • binary heap extraction sorting
6. std::sort, custom comparators and STL sorting utilities90 min
   • introsort hybrid algorithm
   • lambda expressions as comparators
   • std::stable_sort usage

Hands-on project: Build an efficient sorting benchmark suite comparing merge sort, quick sort, and std::sort over datasets of one million integers.

You can solve combinatorial generation and constraint satisfaction problems using systematic recursion trees and state pruning.

1. Recursion fundamentals and the call stack90 min
   • base cases and inductive steps
   • activation record stack frames
   • tail recursion optimization
2. Subsets, permutations and combinations120 min
   • include-exclude pattern
   • lexicographic permutation generation
   • duplicate elimination strategies
3. N-Queens and the Sudoku solver120 min
   • board state representation
   • conflict checking in O(1)
   • backtracking state restoration
4. Rat in a maze and word search90 min
   • visited matrix marking
   • multi-directional DFS traversal
   • grid boundary constraints
5. Pruning and backtracking optimization90 min
   • bounding functions
   • state space tree reduction
   • memoized constraints

Hands-on project: Implement an optimized Sudoku solver and N-Queens visualizer with pruning to eliminate invalid branch explorations early.

You can construct singly, doubly, and circular linked lists from raw pointers with robust memory reclamation and fast pointer manipulation.

1. Singly, doubly and circular linked lists built with pointers90 min
   • node struct definition with raw pointers
   • head and tail pointer maintenance
   • sentinel dummy nodes
2. Insertion, deletion and traversal with manual memory management90 min
   • node insertion at head, tail, and arbitrary index
   • memory deallocation with delete
   • edge cases with empty lists
3. Reversal: iterative and recursive90 min
   • three-pointer iterative reversal
   • recursive stack reversal unwinding
   • sub-list partial reversal
4. Fast and slow pointers: cycle detection (Floyd's algorithm)90 min
   • tortoise and hare pointer traversal
   • cycle start node identification
   • middle element extraction
5. Merge, sort, palindrome and intersection problems120 min
   • merge two sorted lists
   • merge sort for linked lists
   • Y-shaped intersection node finding

Hands-on project: Build an LRU Cache using a doubly linked list and an STL hash map for O(1) get and put operations.

You can solve expression evaluation and monotonic sequence problems using stack, queue, and deque data structures.

1. Stack implementation (array and linked list) and applications90 min
   • LIFO contract implementation
   • dynamic array backing vs linked list backing
   • function call stack simulation
2. Queue, circular queue and deque90 min
   • FIFO contract implementation
   • circular array buffer wrapping
   • double-ended queue operations
3. Monotonic stack and monotonic queue120 min
   • increasing and decreasing stack invariants
   • sliding window maximum with deque
   • amortized O(1) queue operations
4. Next greater element and stock span90 min
   • right-to-left stack traversal
   • span calculation with index tracking
   • largest rectangle in histogram
5. Implementing a stack using queues and vice versa90 min
   • push-heavy vs pop-heavy stack implementation
   • queue implementation using two stacks
   • amortized complexity trade-offs
6. Expression evaluation and balanced parentheses90 min
   • infix to postfix (RPN) conversion
   • postfix evaluation algorithm
   • matching bracket validation

Hands-on project: Code a robust infix expression calculator supporting operator precedence, parentheses, and variable substitution using stacks.

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

1. Binary trees and traversals (in / pre / post / level order)120 min
   • recursive DFS traversals
   • iterative traversal using stacks
   • BFS level-order traversal with queues
2. Height, diameter, views and lowest common ancestor (LCA)120 min
   • bottom-up tree property calculation
   • left and right view extraction
   • recursive LCA search
3. Binary Search Trees: insert, delete and search120 min
   • BST property invariants
   • deletion successor and predecessor logic
   • validation of BST properties
4. Balanced trees: AVL and Red-Black overview90 min
   • tree rotation mechanics (LL, RR, LR, RL)
   • balance factor maintenance
   • Red-Black color invariants
5. Tries (prefix trees)90 min
   • trie node structure with character arrays
   • insert and search methods
   • prefix matching queries
6. Segment Trees and Fenwick Trees (BIT)120 min
   • range query and point update structures
   • lazy propagation in segment trees
   • binary indexed tree bit manipulation

Hands-on project: Build an autocomplete engine using a Trie data structure with frequency-based suggestion sorting.

You can process stream data and find top-K elements efficiently using binary heaps, priority queues, and hash table collision strategies.

1. Min-heaps, max-heaps and heapify90 min
   • complete binary tree array representation
   • sift-up and sift-down operations
   • linear-time buildHeap algorithm
2. std::priority_queue and Top-K problems90 min
   • custom comparators in priority_queue
   • finding K-th largest element
   • merge K sorted lists
3. Finding the median in a data stream90 min
   • balanced dual heap architecture
   • stream ingestion logic
   • amortized O(log N) insertion
4. Hash tables, hash functions and collisions90 min
   • hash function design principles
   • separate chaining collision resolution
   • open addressing and probing techniques
5. unordered_map and unordered_set patterns90 min
   • load factor and rehashing
   • custom hash structures for user types
   • average O(1) lookup behavior
6. Frequency counting and subarray-sum problems90 min
   • subarray sum equals K with hash maps
   • longest consecutive sequence
   • majority element algorithms

Hands-on project: Build a real-time streaming median calculator that processes live numerical inputs using dual heaps.

You can model complex network relationships and solve shortest-path, minimum spanning tree, and connectivity problems using advanced graph algorithms.

1. Graph representations: adjacency list and matrix90 min
   • directed and undirected weighted edges
   • adjacency list memory efficiency
   • adjacency matrix dense graph trade-offs
2. Breadth-First Search (BFS) and Depth-First Search (DFS)120 min
   • queue-based level traversal
   • recursive and iterative DFS
   • connected component counting
3. Connected components and cycle detection90 min
   • directed graph cycle detection with recursion stack
   • undirected graph cycle check
   • articulation points and bridges
4. Topological sorting (Kahn's algorithm and DFS)90 min
   • dependency graph ordering
   • in-degree tracking with Kahn's algorithm
   • course schedule validation
5. Shortest paths: Dijkstra, Bellman-Ford and Floyd-Warshall150 min
   • greedy shortest path with priority queues
   • negative weight cycle detection with Bellman-Ford
   • all-pairs shortest paths in O(V^3)
6. Minimum Spanning Tree: Kruskal and Prim120 min
   • greedy edge selection
   • Kruskal's algorithm with sorted edge lists
   • Prim's algorithm with priority queues
7. Union-Find (Disjoint Set Union)90 min
   • path compression heuristic
   • union by rank and size
   • cycle detection in undirected graphs

Hands-on project: Build a GPS route optimization tool using Dijkstra's algorithm and adjacency lists loaded from map coordinate files.

You can solve overlapping subproblem optimization challenges using memoization, tabulation, and state compression across 1D, 2D, and tree domains.

1. DP fundamentals: memoization vs tabulation90 min
   • top-down recursion with caching
   • bottom-up iterative table filling
   • space optimization techniques
2. 1D DP: climbing stairs, house robber and Fibonacci90 min
   • state transition recurrence relations
   • space reduction from O(N) to O(1)
   • house robber constraint patterns
3. Knapsack patterns: 0/1 and unbounded120 min
   • 0/1 knapsack state table
   • unbounded coin change variations
   • subset sum partition problems
4. Subsequence DP: LIS, LCS and edit distance120 min
   • Longest Increasing Subsequence with binary search
   • Longest Common Subsequence matrix construction
   • Levenshtein edit distance operations
5. DP on grids and matrices90 min
   • unique paths with obstacles
   • minimum path sum in grid
   • matrix chain multiplication
6. DP on trees and bitmask DP120 min
   • maximum path sum in binary trees
   • travelling salesperson problem with bitmasks
   • state compression techniques

Hands-on project: Implement an optimal sequence alignment and edit distance tool with traceback path reconstruction for bioinformatics analysis.

You can apply greedy exchange arguments, bitwise bitmask tricks, and modular arithmetic number theory in optimization problems.

1. Greedy strategy and the exchange argument60 min
   • proof by contradiction in greedy choices
   • optimal substructure property
   • when greedy fails vs dynamic programming
2. Activity selection, interval scheduling and job sequencing90 min
   • activity sorting by finish time
   • interval merging and overlapping removal
   • job sequencing with deadlines
3. Bit manipulation tricks and bitmasking90 min
   • bitwise AND, OR, XOR, and shift operations
   • finding single number using XOR
   • power of two checks and set bit counting
4. Number theory: GCD, Sieve of Eratosthenes and modular arithmetic90 min
   • Euclidean algorithm for GCD
   • prime generation with Sieve of Eratosthenes
   • modular exponentiation and inverse modulo
5. Huffman coding and fractional knapsack60 min
   • prefix code tree construction
   • frequency-based greedy selection
   • fractional value optimization

Hands-on project: Build an interval scheduling scheduler and Huffman coding compression utility using greedy priority queues.

You can test, containerize, deploy, and monitor C/C++ applications in production environments, culminating in an end-to-end algorithmic platform capstone.

1. Unit testing and test-driven development with Google Test90 min
   • ASSERT and EXPECT test macros
   • mocking functions and classes
   • code coverage reports with gcov and lcov
2. Memory safety verification with Valgrind and AddressSanitizer90 min
   • detecting buffer overflows and memory leaks
   • compiler instrumentation flags (-fsanitize=address)
   • debugging segmentation faults with GDB
3. Build systems and CI automation with CMake and GitHub Actions90 min
   • CMakeLists.txt configuration and target linking
   • automated build and test workflows in CI
   • compiler warning flags and static analysis
4. Containerizing C/C++ binaries with multi-stage Dockerfiles90 min
   • compiling static binaries in builder containers
   • minimal scratch and Alpine runtime images
   • container health checks and resource limits
5. Observability: structured logging, metrics, and alerting90 min
   • structured log formats for request tracking
   • exporting latency metrics to Prometheus
   • configuring alerting thresholds for memory consumption
6. Capstone project integration and mock technical interviews120 min
   • end-to-end system integration of graph and DP modules
   • timed mock coding interview simulation
   • resume review and GitHub portfolio polish

Hands-on project: Deploy the complete algorithmic engine capstone as a containerized microservice with Google Test suites, automated CI pipelines, Prometheus metrics, and structured JSON logging.