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.
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.
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.
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.