DSA Course

Lesson 1 • Introduction to Data Organization

Covers primitive vs. composite data types and memory layout concepts. Establishes vocabulary used throughout the course.

Lesson 2 • Arrays and Strings

Examines contiguous memory storage via arrays and character sequences. Connects indexing mechanics to later search and sort algorithms.

Lesson 3 • Complexity Analysis Basics

Introduces Big-O, Big-Theta, and Big-Omega notations for evaluating efficiency. Enables students to compare data structure operations quantitatively.

Lesson 4 • Stacks and Queues

Defines LIFO and FIFO (Last In, First Out and First In, First Out) access patterns and their implementations. Demonstrates real-world use cases such as expression parsing and scheduling.

Lesson 1 • Classic Recursive Algorithms

Applies recursion to factorial, Fibonacci, and power functions. Reinforces pattern recognition for recursive problem solving.

Lesson 2 • Recursive Thinking Fundamentals

Establishes base cases, recursive cases, and call stack behavior. Builds intuition needed before tackling tree and graph algorithms.

Lesson 3 • Divide and Conquer Strategy

Formalizes splitting problems into independent halves and merging results. Prepares students for merge sort and quick sort in the next chapter.

Lesson 1 • Efficient Comparison-Based Sorts

Implements merge sort and quick sort using divide and conquer. Analyzes average and worst-case performance differences between the two.

Lesson 2 • Elementary Sorting Algorithms

Covers bubble, selection, and insertion sort with step-by-step traces. Establishes baseline complexity benchmarks for comparison with advanced sorts.

Lesson 3 • Non-Comparison Sorting Methods

Introduces counting sort, radix sort, and bucket sort for linear-time sorting. Shows when integer or bounded-range data enables sub-quadratic guarantees.

Lesson 4 • Sorting Algorithm Selection

Guides decision-making based on data size, type, and memory constraints. Synthesizes chapter content into a practical selection framework.

Lesson 1 • Binary Tree Traversals

Implements in-order, pre-order, post-order, and level-order traversals. Connects traversal choice to specific output requirements such as sorted output.

Lesson 2 • Binary Search Trees

Covers BST (Binary Search Tree) insertion, deletion, and search with complexity analysis. Demonstrates how ordering invariants enable efficient lookup.

Lesson 3 • Heaps and Priority Queues

Builds min-heaps and max-heaps using array representation and heap operations. Connects heap structure to heap sort and priority-based scheduling.

Lesson 4 • Balanced BSTs (Binary Search Trees) and AVL Trees

Introduces height-balancing via AVL rotations to maintain O(log n) guarantees. Prepares students for red-black trees and B-trees in advanced topics.

Lesson 1 • Hash Table Operations and Analysis

Implements insert, delete, and search with amortized complexity analysis. Connects theoretical guarantees to practical implementation decisions.

Lesson 2 • Advanced Hashing Applications

Explores consistent hashing, Bloom filters, and cryptographic hash use cases. Extends hash table knowledge to distributed and probabilistic systems.

Lesson 3 • Collision Resolution Strategies

Compares chaining and open addressing techniques for handling collisions. Analyzes load factor impact on performance for each strategy.

Lesson 1 • Advanced Graph Topics

Introduces topological sort, strongly connected components, and network flow basics. Prepares students for algorithm design problems in competitive and applied contexts.

Lesson 2 • Graph Representation and Terminology

Defines directed, undirected, weighted, and cyclic graphs with adjacency structures. Establishes the representation choices that affect algorithm efficiency.

Lesson 3 • Minimum Spanning Trees

Implements Kruskal and Prim algorithms using union-find and priority queues. Connects MST (Minimum Spanning Tree) concepts to network design and clustering applications.

Lesson 4 • Graph Traversal Algorithms

Implements BFS (Breadth-First Search) and DFS (Depth-First Search) with explicit queue and stack management. Applies traversals to connectivity detection and cycle identification.

Lesson 1 • DP (Dynamic Programming) on Trees and Graphs

Extends DP (Dynamic Programming) to tree structures and DAG-based problems. Connects graph traversal knowledge to state-space DP (Dynamic Programming) formulations.

Lesson 2 • DP (Dynamic Programming) on Sequences and Intervals

Applies DP (Dynamic Programming) to longest increasing subsequence and interval scheduling problems. Extends pattern recognition to two-pointer and binary search optimizations.

Lesson 3 • DP (Dynamic Programming) Principles and Memoization

Defines overlapping subproblems and optimal substructure as DP (Dynamic Programming) prerequisites. Introduces top-down memoization as the first implementation strategy.

Lesson 4 • Bottom-Up Tabulation

Converts memoized solutions into iterative table-filling approaches. Demonstrates space optimization by reducing table dimensions.

Lesson 1 • Trie and Suffix Structures

Implements prefix trees for fast string search and autocomplete. Introduces suffix arrays for pattern matching in large text corpora.

Lesson 2 • Segment Trees and Fenwick Trees

Builds range query and point update structures for efficient interval operations. Compares segment trees and Fenwick trees by implementation complexity and use case.

Lesson 3 • Amortized Analysis and Advanced Topics

Applies aggregate, accounting, and potential methods to analyze data structure sequences. Introduces skip lists and self-adjusting structures as advanced alternatives.

Lesson 4 • Union-Find and Disjoint Sets

Implements union by rank and path compression for near-constant-time operations. Applies union-find to dynamic connectivity and Kruskal MST (Minimum Spanning Tree).