Stage 1: Foundations of JavaScript and Algorithmic Thinking

Duration: 1 week
 Objective: Build a strong foundation in JavaScript and understand basic
algorithmic concepts.
 Topics:
1. JavaScript Basics:
 Variables, data types, loops, conditionals, and functions.
2. ES6+ Concepts:
 Arrow functions, destructuring, spread/rest operators, and
template literals.
3. Algorithm Basics:
 What is an algorithm?
 Importance of pseudocode.
 Steps to approach problem-solving.
4. Time and Space Complexity:
 Big O notation.
 Analyzing simple examples like loops and nested loops.
 Activities:
o Write simple JavaScript functions (e.g., finding the largest number in
an array).
o Practice converting pseudocode to JavaScript.

Stage 2: Understanding Data Structures

Duration: 4 weeks
  Objective: Learn core data structures and how to implement them using
JavaScript.
Week 1: Arrays and Strings
 Concepts:
o Arrays: Basics, operations (push, pop, shift, unshift), and traversal.
o Strings: Operations (concatenation, slicing, reversing, etc.).
o Two-pointer technique.
 Implementation:
o Reverse a string.
o Merge two sorted arrays.
o Check for anagrams.
 Exercises:
o LeetCode Easy: Two Sum, Valid Anagram.
Week 2: Stacks and Queues
 Concepts:
o Stack: LIFO, operations (push, pop, peek).
o Queue: FIFO, operations (enqueue, dequeue).
o Applications (e.g., backtracking, BFS).
 Implementation:
o Build stack and queue classes in JavaScript.
o Balanced parentheses check.
 Exercises:
o Implement a browser's back/forward feature using stacks.
Week 3: Linked Lists
  Concepts:
o Singly and doubly linked lists.
o Traversal, insertion, and deletion.
o Applications of linked lists.
 Implementation:
o Create a linked list class.
o Reverse a linked list.
 Exercises:
o Detect a cycle in a linked list.
Week 4: HashMaps and Sets
 Concepts:
o HashMap: Key-value pairs, collision handling.
o Set: Unique elements and operations.
o Applications (e.g., frequency counting, duplicates removal).
 Implementation:
o Implement a basic hash table.
o Find the first unique character in a string.
 Exercises:
o Group anagrams using a HashMap.

Stage 3: Core Algorithms

Duration: 4 weeks
 Objective: Master fundamental algorithms with JavaScript
implementations.
Week 1: Sorting Algorithms
 Concepts:
o Bubble sort, selection sort, insertion sort.
o Merge sort, quicksort.
 Implementation:
o Write functions for each sorting algorithm.
o Visualize sorting with console.table() or web animations.
 Exercises:
o Sort an array of objects by a key (e.g., age).
Week 2: Searching Algorithms
 Concepts:
o Linear search and binary search.
o Applications of binary search (search in rotated arrays, etc.).
 Implementation:
o Implement binary search iteratively and recursively.
 Exercises:
o Find the square root of a number using binary search.
Week 3: Recursion and Backtracking
 Concepts:
o Understanding recursion (base case and recursive case).
o Backtracking (solving the N-Queens problem, subsets generation).
 Implementation:
o Solve the factorial problem using recursion.
 o Implement Sudoku solver using backtracking.
 Exercises:
o Generate all permutations of an array.
Week 4: Divide and Conquer
 Concepts:
o Problem-solving approach with divide and conquer.
o Examples: Merge sort, quicksort, maximum subarray sum.
 Implementation:
o Solve problems using divide and conquer techniques.
 Exercises:
o Maximum subarray sum (Kadane’s algorithm).

Stage 4: Advanced Data Structures

Duration: 3 weeks
 Objective: Explore more complex data structures and their
implementations.
Week 1: Trees and Binary Search Trees
 Concepts:
o Tree traversal (in-order, pre-order, post-order).
o Binary search tree (BST) operations.
 Implementation:
o Create a BST class.
o Implement insert, search, and delete in a BST.
 Exercises:
 o Find the height of a binary tree.
Week 2: Heaps and Priority Queues
 Concepts:
o Min-heap and max-heap.
o Priority queue implementation.
 Implementation:
o Implement a min-heap using an array.
o Solve "Kth largest element in an array."
 Exercises:
o Merge k sorted arrays.
Week 3: Graphs
 Concepts:
o Graph representation (adjacency list, matrix).
o Traversal algorithms: BFS, DFS.
o Applications (shortest path, cycle detection).
 Implementation:
o Build a graph using an adjacency list.
o Implement BFS and DFS.
 Exercises:
o Solve "Shortest path in an unweighted graph."

Stage 5: Dynamic Programming

Duration: 2 weeks
  Objective: Learn problem-solving techniques for optimization problems.
 Topics:
o Fibonacci sequence (top-down and bottom-up approach).
o Knapsack problem.
o Longest common subsequence.
 Implementation:
o Solve DP problems using memoization and tabulation.
 Exercises:
o Solve "Climbing Stairs," "House Robber," and "Coin Change."

Stage 6: Capstone Project

Duration: 1 week
 Objective: Apply learned skills to build a complete project.
 Project Idea:
o Build a Pathfinding Visualizer:
 Implement algorithms like BFS, DFS, and A*.
 Create a grid-based UI to demonstrate the pathfinding process.
o Online Store Search Engine:
 Create a mini-eCommerce app with a search feature using
binary search.

CHAPTER 1:
JavaScript Basics: Variables, Data Types, Loops, Conditionals, and
Functions
This lesson will cover the fundamental concepts of JavaScript, including variables,
data types, loops, conditionals, and functions. Each section includes explanations,
examples, and exercises to help solidify your understanding.

1. Variables in JavaScript
What Are Variables?
Variables are containers for storing data values. In JavaScript, you can declare
variables using var, let, or const.

Best Practices:
 Use let for variables that can change.
 Use const for variables that should not change.
 Avoid var as it has outdated scoping rules.
Exercise:
Declare three variables: your name, your age, and whether you are a student.
Print them to the console.

2. Data Types in JavaScript

JavaScript Data Types:
1. Primitive Types:
o String
o Number
o Boolean
o Null
o Undefined
o Symbol
2. Reference Types:
o Object (including Arrays and Functions)
Exercise:
Create a variable for each data type and print its type using typeof.

3. Loops in JavaScript
What Are Loops?
Loops are used to execute a block of code multiple times.
Types of Loops:
1. For Loop
2. While Loop
3. Do-While Loop
4. For...of Loop (for arrays)
5. For...in Loop (for objects)
Examples:
4. Conditionals in JavaScript
What Are Conditionals?
Conditionals are used to perform different actions based on different conditions.
Exercise:
Write a program that checks if a number is positive, negative, or zero.
5. Functions in JavaScript
What Are Functions?
Functions are blocks of code designed to perform specific tasks. They are executed
when "called".
Exercise:
Write a function to calculate the factorial of a number.
Recap and Practice
1. Variables:
o Use let and const.
o Practice declaring and updating variables.
2. Data Types:
o Identify and use primitive and reference types.
3. Loops:
o Write loops to handle arrays and ranges.
 4. Conditionals:
o Write conditional statements and explore the ternary operator.
5. Functions:
o Write functions to solve small problems like finding the maximum of
three numbers.

CHAPTER 2

JavaScript ES6+ Concepts: Arrow Functions, Destructuring,

Spread/Rest Operators, and Template Literals
This lesson covers key ES6+ concepts that enhance JavaScript programming. Each
section includes explanations, examples, and exercises to help you understand
and apply these features effectively.

1. Arrow Functions
What Are Arrow Functions?
Arrow functions provide a concise syntax for writing functions in JavaScript. They
are particularly useful for shorter functions and have a simpler this binding
compared to regular functions.
Key Features:
 No ‘this’ binding: Arrow functions do not have their own this, making them
ideal for use in callbacks.
 Concise syntax: Ideal for simple functions.
Exercise:
Convert the following regular function into an arrow function:
function subtract(a, b) {
return a - b;
}
2. Destructuring
What Is Destructuring?
Destructuring allows you to unpack values from arrays or properties from objects
into distinct variables.
Exercise:
Destructure the following object to extract the title and author properties:
const book = {
title: "JavaScript Essentials",
author: "John Doe",
pages: 300
};

3. Spread and Rest Operators

What Are Spread and Rest Operators?
The spread operator (...) expands elements of an array or object, while the rest
operator collects multiple elements into a single array or object.
Spread Operator:
Exercise:
Use the spread operator to combine two arrays and the rest operator to write a
function that calculates the product of all arguments passed to it.
4. Template Literals
What Are Template Literals?
Template literals are strings enclosed by backticks (``) that allow embedded
expressions using the ${} syntax.

Exercise:
Write a template literal that includes a person's name, age, and city using
variables.
 CHAPTER 3
Algorithm Basics: Understanding Algorithms, Pseudocode, and Problem-Solving
Steps
This lesson introduces algorithms, explains the importance of pseudocode, and
outlines a structured approach to problem-solving. Each concept is reinforced
with examples and exercises to solidify your understanding.

1. What Is an Algorithm?
Definition
An algorithm is a step-by-step procedure or formula for solving a problem. It
consists of a finite set of instructions that, when executed, produce a desired
outcome.
Characteristics of a Good Algorithm:
 Clear and Unambiguous: Each step is precisely defined.
 Finite: It must terminate after a finite number of steps.
 Input and Output: Accepts inputs and produces outputs.
 Feasibility: Steps must be practical and executable.
 Independent: Should not depend on a specific programming language.
Example:
An algorithm to find the sum of two numbers:
1. Start.
2. Input two numbers: a and b.
3. Calculate the sum: sum = a + b.
4. Output the result: sum.
5. End.
2. Importance of Pseudocode
What Is Pseudocode?
Pseudocode is a plain-language description of an algorithm. It uses a mix of
natural language and programming-like syntax to outline the logic without
worrying about specific syntax.
Benefits of Pseudocode:
 Clarity: Helps break down complex logic into manageable steps.
 Language Independence: Can be translated into any programming
language.
 Collaboration: Enables team members to understand and discuss the logic
without technical barriers.

Pseudocode Example:

 Algorithm to find the largest number in an array:

1. Start.
2. Set `largest` to the first element of the array.
3. For each element in the array:
a. If the element is greater than `largest`, update `largest`.
4. Output `largest`.
5. End.

3. Steps to Approach Problem-Solving

Structured Problem-Solving Framework:
 1. Understand the Problem:
o Carefully read the problem statement.
o Identify inputs, outputs, and constraints.
Example:
Problem: Find the maximum number in a list.
o Input: A list of numbers.
o Output: The largest number in the list.
2. Break the Problem into Smaller Parts:
o Divide the problem into manageable components.
Example:
o Step 1: Loop through the list.
o Step 2: Compare each number to find the largest.
3. Write Pseudocode:
o Plan the logic using pseudocode.
Example Pseudocode:
1. Start.
2. Initialize `max` to the first number in the list.
3. For each number in the list:
a. If the number is greater than `max`, update `max`.
4. Output `max`.
5. End.
4. Translate Pseudocode into Code:
 Write code in your chosen programming language based on the
pseudocode.

5. Test the Solution:

o Test the algorithm with different inputs to ensure correctness.
Test Cases:
o Input: [3, 5, 7, 2, 8] → Output: 8
o Input: [-1, -5, -3, -10] → Output: -1
o Input: [0, 0, 0] → Output: 0
6. Optimize and Refactor:
1. Check for ways to improve efficiency.
2. Simplify the code without altering functionality.

Exercises
1. Write pseudocode for calculating the factorial of a number.
 2. Translate the following pseudocode into JavaScript:
Pseudocode:
1. Start.
2. Input a list of numbers.
3. Initialize `sum` to 0.
4. For each number in the list:
a. Add the number to `sum`.
5. Output `sum`.
6. End.

3. Solve the problem of finding the second largest number in an array. Provide
the pseudocode and JavaScript implementation.

CHAPTER 4
Time and Space Complexity: Big O Notation and Analyzing Loops
This lesson introduces the fundamentals of time and space complexity, focusing
on Big O notation and the analysis of basic examples like loops and nested loops.
By the end, you’ll have a solid understanding of how to measure and optimize
algorithm performance.

1. What Is Time and Space Complexity?

Time Complexity
Time complexity measures the amount of time an algorithm takes to complete as
a function of the input size. It helps evaluate how an algorithm’s performance
scales as the input grows.
Space Complexity
Space complexity measures the amount of memory an algorithm uses as a
function of the input size. This includes:
 Fixed Part: Memory required to store constants, variables, and program
instructions.
 Variable Part: Memory required for dynamic allocations, such as arrays and
recursion.

2. Big O Notation
Big O notation provides a high-level understanding of an algorithm’s efficiency. It
describes the upper bound of an algorithm’s growth rate, helping to predict its
worst-case performance.

Common Big O Notations:

 Notation Description Example

O(1) Constant Time Accessing an array element.

O(log n) Logarithmic Time Binary search.

O(n) Linear Time Iterating through a list.

O(n log n) Quasilinear Time Merge sort.

O(n^2) Quadratic Time Nested loops.

O(2^n) Exponential Time Solving the Tower of Hanoi.

O(n!) Factorial Time Permutations of a string.

3. Analyzing Examples
Example 1: Single Loop

 Time Complexity: O(n) (Linear) because the loop runs n times.

 Space Complexity: O(1) (Constant) because no additional memory is used
relative to the input size.
 Example 2: Nested Loops
 Time Complexity: O(n^2) (Quadratic) because the outer loop runs n times,
and for each iteration, the inner loop also runs n times.
 Space Complexity: O(1) (Constant) because no extra memory depends on
n.
Example 3: Logarithmic Growth

 Time Complexity: O(log n) (Logarithmic) because the search range is halved

in each iteration.
 Space Complexity: O(1) (Constant) since it only uses a few variables.
4. Key Insights for Loops and Nested Loops
Single Loops:
 The number of iterations directly impacts time complexity.
 Example: A loop running n times has O(n) complexity.
Nested Loops:
 Time complexity multiplies with the number of nested iterations.
 Example: Two nested loops running n times each result in O(n^2).
Breaking Loops:
 Breaking out of a loop early can improve average-case performance but
does not change worst-case time complexity.

5. Exercises
Exercise 1: Analyze Time Complexity
Determine the time and space complexity of the following function:

Exercise 2: Nested Loops

Write a JavaScript function to generate all unique pairs from an array and analyze
its time complexity.
Exercise 3: Optimize Performance
Given a sorted array, implement a function to find if two numbers sum to a target
value with O(n) com

BIG ‘O’ Notation

1. Time Complexities
2. Data Structure (Array[]}
3. Objects ({} or newObjects())
4. Sets (newSets())

Time Complexities

Big-O-Notation Growth Rate Example

0(1) Constant Accessing an

array element
Arr[0]
0(log n) Logarithmic Binary Search

0(n) Linear Looping through

an array.

0(n log n) Quasilinear Merge sort,

quick sort

0(n2) Quadratic Nested Loops

0(2n) Exponential Fibonacci (Brute-

force recursion)

0(n!) Factorial Permutations

(Brute-force
approach)
 Data Structure (Array[]}

Big-O- Operation Example

Notation

0(1) Access (arr[i]) Console.log(arr[2]);

0(1) Insert at end Arr.push(10);

(push)

0(1) Remove from Arr.pop();

end (pop)

0(n) Insert at Arr.unshift();

beginning
(unshift)
0(n) Remove from the Arr.shift();
beginning (shift)

0(n) Insert in middle Arr.splice(2, 0, 99);

(splice)

0(n) Search (indexOf, Arr.indexOf(10);

includes)

0(n log n) Sorting (sort) Arr.sort();