Data Structures and Algorithms using Javascript

You can analyse time and space complexity with Big-O notation and implement array and string manipulations in JavaScript.

1. JavaScript for DSA90 min
   • Typed arrays and memory layout
   • ES6 destructuring and spread operators
   • Garbage collection in V8
   • Performance pitfalls of built-in methods
2. Time and space complexity2 hrs
   • Asymptotic analysis
   • Worst-case and average-case bounds
   • Auxiliary space measurement
   • Memory overhead of JavaScript objects
3. Big-O intuition2 hrs
   • Logarithmic growth patterns
   • Amortised analysis of dynamic arrays
   • Identifying nested loops
   • Recursion stack depth tracking
4. Arrays and strings2.5 hrs
   • In-place array manipulations
   • String immutability and character codes
   • Buffer management
   • Unicode and UTF-16 surrogate pairs
5. The problem-solving mindset2 hrs
   • Deconstructing problem statements
   • Edge case identification
   • Dry-running algorithms on paper
   • Writing modular test suites

Hands-on project: Write a robust JavaScript utility module that handles complex array transformations and validates string inputs with O(n) runtime complexity.

You can solve linear data structure problems efficiently using sliding windows and multi-pointer strategies.

1. The two-pointer technique2 hrs
   • Opposite-direction pointers
   • Same-direction tortoise and hare
   • Partitioning arrays
   • Handling sorted datasets
2. Sliding window2.5 hrs
   • Fixed-size window calculations
   • Dynamic window contraction and expansion
   • Subarray optimization
   • Frequency map maintenance
3. Prefix sums2 hrs
   • Cumulative frequency arrays
   • Range sum queries in O(1)
   • Difference arrays for interval updates
   • Multi-dimensional prefix sums
4. Recognising the pattern1.5 hrs
   • Identifying monotonicity
   • Translating constraints to window conditions
   • Choosing between pointers and binary search
   • Common interview traps
5. Practice problems2 hrs
   • Longest substring without repeating characters
   • Container with most water
   • Minimum size subarray sum
   • Trapping rain water

Hands-on project: Implement an API rate limiter function using a sliding window log algorithm in Node.js with sub-millisecond execution times.

You can design O(1) average lookup systems and frequency-counting engines using native JavaScript Maps and Sets.

1. Hash maps and sets2 hrs
   • Map vs Object performance in V8
   • Set operations and union intersections
   • Custom hash function design
   • Memory management with WeakMap
2. Frequency counting2 hrs
   • Counting patterns in arrays and strings
   • Anagram detection algorithms
   • Top-K frequent elements retrieval
   • Majority element identification
3. Grouping and lookups2 hrs
   • Two sum variations
   • Group shifted strings
   • Subarray sum equals K
   • Sparse vector representation
4. Collision concepts2 hrs
   • Hash table load factor
   • Chaining vs open addressing
   • Worst-case O(N) degradation
   • Cryptographic vs non-cryptographic hashes
5. Practice problems2 hrs
   • Longest consecutive sequence
   • Valid Sudoku solver validator
   • Ransom note generator
   • Group anagrams pipeline

Hands-on project: Build an in-memory caching system with TTL expiration and collision resolution using custom hash map structures in TypeScript.

You can manipulate pointers, reverse sequences, and detect structural cycles in singly and doubly linked lists.

1. Singly and doubly linked lists2 hrs
   • Node class architecture
   • Pointer redirection mechanics
   • Insertion and deletion at arbitrary positions
   • Sentinel node patterns
2. Reversal and cycle detection2 hrs
   • Iterative list reversal
   • Recursive pointer flipping
   • Floyd's cycle-finding algorithm
   • Finding cycle start nodes
3. Fast and slow pointers2 hrs
   • Finding the middle of a list
   • Palindrome linked list verification
   • Reordering list structures
   • Removing Nth node from end
4. Merging lists2 hrs
   • Merging two sorted lists
   • Merge K sorted lists with min-heaps
   • Intersection of two linked lists
   • Flattening multi-level lists
5. Practice problems2 hrs
   • Reverse nodes in K-group
   • Copy list with random pointer
   • Add two numbers represented by lists
   • Swap nodes in pairs

Hands-on project: Implement an LRU Cache in JavaScript using a custom doubly linked list paired with a hash map for O(1) get and put operations.

You can solve expression evaluation and monotonic sequence problems using stacks, queues, and deques.

1. Stacks and their uses2 hrs
   • LIFO principle implementation
   • Valid parentheses matching
   • Function call stack simulation
   • Browser history navigation stack
2. Queues and deques2 hrs
   • FIFO queue with array pointers
   • Circular queue implementation
   • Double-ended queue operations
   • Moving average from data stream
3. The monotonic stack2.5 hrs
   • Next greater element pattern
   • Largest rectangle in histogram
   • Daily temperatures calculation
   • Stock span problem
4. Expression evaluation1.5 hrs
   • Prefix and postfix notation
   • Reverse Polish Notation evaluator
   • Basic calculator with parentheses
   • Operator precedence parsing
5. Practice problems2 hrs
   • Sliding window maximum
   • Implement queue using stacks
   • Evaluate reverse polish notation
   • Car fleet simulation

Hands-on project: Build a syntax parser and infix-to-postfix arithmetic expression evaluator using stack data structures.

You can break down complex combinatorial problems into recursive state spaces and explore solutions via backtracking.

1. Recursion and the call stack3 hrs
   • Base cases and recursive steps
   • Call stack frame inspection
   • Tail call optimization
   • Converting recursion to iteration
2. Divide and conquer4 hrs
   • Recurrence relation analysis
   • Master theorem application
   • Maximum subarray sum with divide and conquer
   • Matrix exponentiation basics
3. Backtracking5 hrs
   • State-space tree exploration
   • Pruning invalid branches early
   • Choice, exploration, and un-choice pattern
   • State restoration techniques
4. Permutations and combinations4 hrs
   • Generating all subsets (Power Set)
   • Permutations with duplicate elements
   • Combination sum variations
   • Partition to K equal sum subsets
5. Practice problems4 hrs
   • N-Queens problem placement
   • Word search grid traversal
   • Letter combinations of a phone number
   • Palindrome partitioning

Hands-on project: Develop a Sudoku solver and constraint satisfaction validator using backtracking state exploration in Node.js.

You can implement logarithmic search variants and comparison sorts while evaluating time-space trade-offs.

1. Binary search and variants2.5 hrs
   • Classic binary search invariants
   • Finding first and last position of element
   • Binary search on answer space
   • Searching in rotated sorted arrays
2. Comparison sorts2 hrs
   • Bubble, insertion, and selection sorts
   • Stability in sorting algorithms
   • Worst-case behavior analysis
   • Custom JavaScript sort comparators
3. Merge and quick sort2.5 hrs
   • Divide and conquer merge sort
   • Partition schemes (Lomuto and Hoare)
   • Quickselect for Kth smallest element
   • Worst-case pivot degradation fixes
4. Sorting-based problems1.5 hrs
   • Interval merging and insertion
   • Meeting rooms scheduling
   • Maximum intervals overlap
   • Custom sorting rules
5. Complexity trade-offs1.5 hrs
   • Time vs space optimization
   • In-place vs out-of-place algorithms
   • Cache locality in sorting
   • When to use non-comparison sorts

Hands-on project: Build an efficient binary search engine with custom comparator functions for searching massive sorted datasets.

You can traverse, search, and balance binary search trees and heap structures to solve hierarchical problem sets.

1. Binary trees and BSTs4 hrs
   • Tree node structures and pointers
   • Binary Search Tree property enforcement
   • Insertion and deletion in BST
   • Lowest common ancestor in BST
2. Tree traversals (DFS/BFS)4 hrs
   • Preorder, inorder, and postorder DFS
   • Level-order BFS traversal using queues
   • Morris traversal for O(1) space
   • Zigzag level order traversal
3. Balanced trees4 hrs
   • Height-balanced tree checks
   • AVL tree rotations (LL, RR, LR, RL)
   • Path sum calculations
   • Diameter and maximum width of binary tree
4. Tree-based problems4 hrs
   • Serialize and deserialize binary tree
   • Binary tree maximum path sum
   • Construct tree from preorder and inorder
   • Trie prefix tree implementation
5. Practice4 hrs
   • Subtree of another tree
   • Validate binary search tree
   • Invert binary tree
   • Count complete tree nodes

Hands-on project: Implement a self-balancing AVL tree or Red-Black tree validation suite with robust insertion and rotation verification.

You can manage dynamic priority datasets and top-K elements using binary heap structures.

1. Heaps2 hrs
   • Min-heap and max-heap invariants
   • Array representation of binary heaps
   • Heapify and sift-up/sift-down operations
   • Building a heap in O(N) time
2. Priority queues2 hrs
   • Priority queue interface design
   • Custom comparators for objects
   • Task scheduler implementation
   • Merge K sorted arrays
3. Top-K problems2 hrs
   • Kth largest element in array
   • Top K frequent words
   • Frequency sort strings
   • K closest points to origin
4. Heap sort2 hrs
   • In-place sorting with heaps
   • Time and space complexity analysis
   • Comparison with quicksort and mergesort
   • External sorting concepts
5. Practice problems2 hrs
   • Find median from data stream
   • Reorganize string frequency
   • Design Twitter feed
   • Sliding window median

Hands-on project: Build a real-time data stream median finder using a dual-heap architecture in JavaScript.

You can model relationships and compute shortest paths or topological ordering using graph traversal algorithms.

1. Graph representations4 hrs
   • Adjacency list vs adjacency matrix
   • Edge list representation
   • Directed and undirected graphs
   • Weighted and unweighted networks
2. BFS and DFS4 hrs
   • Breadth-first search shortest path
   • Depth-first search component discovery
   • Connected components counting
   • Bipartite graph validation
3. Shortest paths4 hrs
   • Dijkstra's algorithm with priority queues
   • Bellman-Ford algorithm for negative weights
   • Floyd-Warshall all-pairs shortest path
   • 0-1 BFS optimization
4. Topological sort4 hrs
   • Directed acyclic graph validation
   • Kahn's algorithm using in-degrees
   • DFS-based finishing time sorting
   • Course schedule dependency resolution
5. Union-find4 hrs
   • Disjoint set union data structure
   • Path compression optimization
   • Union by rank/size
   • Kruskal's minimum spanning tree

Hands-on project: Implement Dijkstra's shortest path algorithm and cycle detection for an interactive map routing engine.

You can solve overlapping subproblem structures using memoization, tabulation, and space-optimized DP state transitions.

1. Recognising DP problems4 hrs
   • Optimal substructure property
   • Overlapping subproblems identification
   • State definition and transitions
   • Top-down vs bottom-up approaches
2. Memoisation and tabulation4 hrs
   • Caching recursive results in JavaScript
   • Iterative table filling strategies
   • Avoiding stack overflow errors
   • Space optimization techniques
3. Classic DP patterns4 hrs
   • Fibonacci and climbing stairs variants
   • House robber consecutive constraints
   • Coin change combinations
   • Longest increasing subsequence
4. Optimising solutions4 hrs
   • Reducing 2D tables to 1D arrays
   • Rolling variable state tracking
   • Bitmask DP for subset states
   • Matrix chain multiplication
5. Practice problems4 hrs
   • Edit distance string transformation
   • Longest common subsequence
   • Partition equal subset sum
   • Burst balloons optimization

Hands-on project: Build an optimal edit-distance and diff-utility engine using bottom-up tabulation and state space compression.

You can recognise the problems these three structures solve and implement them from scratch.

1. Tries and prefix problems90 min
   • Insert and search
   • Autocomplete
   • Memory vs hash map
2. Union-Find for connectivity90 min
   • Union by rank
   • Path compression
   • Cycle detection
3. Segment and Fenwick trees90 min
   • Range sum and min
   • Point updates
   • Lazy propagation idea
4. Choosing the right structure90 min
   • Recognising the signal
   • Complexity trade-offs
   • When a simpler one wins

Hands-on project: Implement a trie with prefix search, a union-find with path compression, and a segment tree with range queries, then solve one interview problem with each and state its time and space complexity.

You can test, containerise, deploy, and monitor production-grade algorithmic services with automated CI/CD pipelines.

1. Unit testing and test-driven development2 hrs
   • Writing Jest test suites for algorithms
   • Property-based testing with edge cases
   • Benchmarking execution time with console.time
   • Memory leak profiling in Node.js
2. Containerisation with Docker2 hrs
   • Multi-stage Dockerfile creation
   • Minimizing Node.js image footprint
   • Environment configuration management
   • Container health checks
3. CI/CD automation2 hrs
   • GitHub Actions workflow configuration
   • Automated test runner integration
   • Linting and static analysis checks
   • Container registry publishing
4. Logging and monitoring2 hrs
   • Structured logging with Winston
   • Performance metrics and latency tracking
   • Prometheus endpoint exposure
   • Debugging production memory spikes
5. Capstone Integration & Interview Simulation2 hrs
   • End-to-end capstone architecture review
   • Mock interview communication strategies
   • Handling live coding pressure
   • Final code review and certification sign-off

Hands-on project: Build, containerise with a multi-stage Dockerfile, unit test with Jest, and deploy a full-featured algorithmic microservice to a cloud VM with Prometheus logging.