Binary Search Tree
Construct dynamic 2D Binary Search Trees element by element. Run animated depth-first traversals (In-order, Pre-order, Post-order) stepping through the recursive call stack.
Array vs ArrayList Memory Resizing
Witness the internal array backing an ArrayList dynamically resize. Compare fixed memory bounds against O(N) copy operations when capacity is exceeded.
2D Array Traversal
Deconstruct nested loops covering Row-Major, Column-Major, and boundary tracing across a 2D integer matrix.
Big-O Complexity
Analyze algorithm efficiency using Big-O notation to describe time and space complexity. Compare O(1) constant time, O(log n) logarithmic, O(n) linear, O(n log n) linearithmic, O(n²) quadratic, and O(2ⁿ) exponential growth rates. Visualize how input size affects runtime, understand best/average/worst case scenarios, and learn to identify complexity by analyzing loops, recursion depth, and data structure operations.
Object Orientation Stack vs Heap
Eliminate aliasing bugs by visualizing Java's Stack vs Heap memory. See how references map to object instances and primitives copy by value.
Heapsort Visualization
Visualize treating a flat array as a Complete Binary Tree. Watch the algorithm Build Max Heap, then extract elements to sort in O(N log N) time without extra memory.
Array & ArrayList Operations
Master array and ArrayList operations in Java including traversal, searching, insertion, deletion, and modification. Compare fixed-size arrays with dynamic ArrayLists, understand index-based access, practice common algorithms like linear search and finding min/max values, and analyze time complexity (O(n) for search, O(1) for access). Learn when to use arrays versus ArrayLists based on performance and flexibility requirements.
Recursion Call Stack Memory
Step through factorial and Fibonacci recursive calls frame-by-frame. Watch the LIFO Call Stack grow and trace return values bubbling up from the Base Case.
Stack & Queue
Compare stack (LIFO - Last In First Out) and queue (FIFO - First In First Out) data structures. Visualize stack operations push() and pop() used in function call stacks, undo mechanisms, and expression evaluation. Explore queue operations enqueue() and dequeue() used in task scheduling, breadth-first search, and print job management. Both structures offer O(1) time complexity for their primary operations.
Sorting Algorithms O(N^2) vs O(N log N)
Visualize Selection, Insertion, and Merge sort line-by-line. Track memory accesses, array swaps, and Big-O efficiency in real time.
Recursion Visualizer
Visualize recursive function calls and the call stack to understand how recursion works. Explore the essential components: base case (stopping condition) and recursive case (function calling itself with modified parameters). Trace classic examples like factorial, Fibonacci sequence, and binary search. Understand stack frames, how recursive calls build up then unwind, and compare recursion with iterative solutions for efficiency and readability.
Inheritance & Polymorphism
Explore object-oriented programming concepts of inheritance (creating subclasses that extend superclasses) and polymorphism (objects taking multiple forms). Understand the 'is-a' relationship, method overriding with @Override annotation, the super keyword for accessing parent class methods, and how polymorphism enables writing flexible code where superclass references can point to subclass objects, allowing dynamic method dispatch at runtime.
Recursive Fibonacci Call Tree
Visualize how a single recursive method spawns a massive Call Tree of overlapping sub-problems. Observe exponential O(2^n) inefficiency.