Data Structures & Algorithms

Mathematical and architectural foundations of Data Structures and Algorithms: Abstract Data Types (ADTs), physical memory topologies, Random Access Machine (RAM) computational modeling, frequency count analysis, and formal asymptotic notations (Big-O, Omega, Theta).

• Unit 1 — Introduction to Data Structures, ADTs & Asymptotic Analysis — Chapter PDF
• Lesson 1 — Data Structures Foundations, Abstract Data Types (ADTs) & Memory Representations
• Lesson 2 — Algorithm Analysis & Asymptotic Complexity Mechanics
• Lesson 3 — Formal Asymptotic Notations (Big-O, Omega, Theta) & Space-Time Trade-offs

Mastering fundamental searching and elementary sorting algorithms: Linear Search, Binary Search halving dynamics, the 32-bit midpoint integer overflow bug, Exchange Sort (Bubble Sort), Selection Sort write minimization, Algorithmic Stability, Inversion Count Theory, and Adaptive Insertion Sort.

• Unit 2 — Simple Sorting and Searching Algorithms — Chapter PDF
• Lesson 1 — Fundamental Search Algorithms: Linear vs. Binary Search & Midpoint Overflow
• Lesson 2 — Simple Exchange & Selection Sorts: Bubble Sort, Stability & Selection Sort
• Lesson 3 — Adaptive Insertion Sort, Inversion Counts & Quadratic Benchmark Comparison

In-depth study of pointer-linked dynamic data structures: Singly Linked Lists, splice invariants, pointer loss anti-patterns, Doubly Linked Lists, Sentinel (Dummy) Node patterns, Circular Linked Lists, Floyd's Cycle-Finding Algorithm (Tortoise and Hare), and LRU cache production architectures.

• Unit 3 — Linked List Data Structure and Its Applications — Chapter PDF
• Lesson 1 — Singly Linked Lists: Node Anatomy, Pointer Invariants & Splice Operations
• Lesson 2 — Doubly Linked Lists, Sentinel Nodes & Bidirectional Navigation
• Lesson 3 — Circular Linked Lists, Ring Buffers & Real-World System Applications

Comprehensive engineering study of the Stack Abstract Data Type (ADT): LIFO formal invariants, contiguous array vs heap-allocated linked node storage topologies, Dijkstra's Shunting-Yard Infix-to-Postfix conversion, Reverse Polish Notation (RPN) evaluation engines, runtime activation call stacks, and backtracking state machines.

• Unit 4 — Stacks, Storage Architectures & Expression Parsing Mechanics — Chapter PDF
• Lesson 1 — Stack Abstract Data Type & Storage Architectures (Array vs Linked List)
• Lesson 2 — Expression Parsing Mechanics: Infix, Postfix & Shunting-Yard Algorithm
• Lesson 3 — Runtime Call Stacks, Backtracking Topologies & Boundary Protection

Engineering foundations of the Queue Abstract Data Type (ADT): FIFO invariants, linear array drifting defects, modulo arithmetic ring buffers, double-ended queues (Deques), sliding window monotonic queues, complete binary heap priority queues, and OS task scheduling architectures.

• Unit 5 — Queues, Circular Buffers & Priority Schedulers — Chapter PDF
• Lesson 1 — Queue Abstract Data Type & Storage Architectures (Linear vs Circular Array vs Linked List)
• Lesson 2 — Double-Ended Queues (Deque) & Monotonic Queue Architectures
• Lesson 3 — Priority Queues, Binary Heaps & Enterprise Scheduling Engines

Comprehensive study of hierarchical non-linear data structures: Tree formal terminology, First-Child/Next-Sibling N-ary representations, binary tree structural classifications, Depth-First (DFS) and Breadth-First (BFS) traversals, recursive vs iterative stack-driven visiting engines, Binary Search Tree (BST) mutations (search, insert, deletion by merging vs copying), and self-balancing AVL rotation fundamentals.

• Unit 6 — Tree Topologies, Binary Traversals & Binary Search Trees — Chapter PDF
• Lesson 1 — Tree Hierarchical Topologies & Binary Tree Structural Axioms
• Lesson 2 — Tree Traversal Topologies: Depth-First (DFS) & Breadth-First (BFS)
• Lesson 3 — Binary Search Trees (BST): Search, Insertion, Deletion Mechanics & AVL Balancing

Advanced computational study of non-linear network topologies: Graph formal specification G=(V,E), Handshaking Lemma, Adjacency Matrix vs. Adjacency List storage architectures, Depth-First Search (DFS) with 3-color cycle detection, Breadth-First Search (BFS) shortest-hop wavefronts, Kahn's DAG topological sorting, Dijkstra's Single-Source Shortest Path algorithm, and Minimum Spanning Trees (Prim's cut engine and Kruskal's Disjoint-Set Union-Find).

• Unit 7 — Graph Topologies, Traversal & Shortest Paths — Chapter PDF
• Lesson 1 — Graph Topologies, Invariant Axioms & Storage Architectures
• Lesson 2 — Graph Traversal Engines: Depth-First (DFS), BFS & Topological Sorting
• Lesson 3 — Shortest Path Routing & Minimum Spanning Forests (Dijkstra, Prim & Kruskal)

Rigorous study of O(n log n) and sub-linear sorting algorithms: Shell Sort gap-sequence mathematics, Merge Sort stable divide-and-conquer and external sorting, Quick Sort Lomuto/Hoare partition schemas and randomised pivot strategies, Heap Sort BuildHeap O(n) proof and in-place extraction, the Omega(n log n) information-theoretic lower bound, and linear-time non-comparison sorts (Counting Sort and Radix Sort LSD/MSD).

• Unit 8 — Advanced Sorting Algorithms — Chapter PDF
• Lesson 1 — Shell Sort Gap Mathematics & Merge Sort Stable Divide-and-Conquer
• Lesson 2 — Quick Sort Partitioning Architectures & In-Place Heap Sort
• Lesson 3 — Linear Sorting & the Omega(n log n) Lower Bound Proof

Comprehensive study of searching algorithms — Linear O(n), Binary O(log n), Interpolation O(log log n), and Fibonacci O(log n) — followed by rigorous treatment of hash tables including hash function design (Division, Mid-Square, Folding), collision resolution via Separate Chaining and Open Addressing (Linear Probing, Quadratic Probing, Double Hashing), load factor analysis, and production applications in Java HashMap, compiler symbol tables, and distributed hash tables.

• Unit 9 — Searching and Hashing — Chapter PDF
• Lesson 1 — Linear, Binary, Interpolation & Fibonacci Search Algorithms
• Lesson 2 — Hash Tables: Functions, Collisions & Open Hashing
• Lesson 3 — Java HashMap Internals, String Hashing & Production Applications