From 87edde16fe79bfb9be2818f7597a6f095e59e8b3 Mon Sep 17 00:00:00 2001 From: Kolade Chris <65571316+Ksound22@users.noreply.github.com> Date: Mon, 9 Mar 2026 13:59:46 +0100 Subject: [PATCH] feat(curriculum): add dsa review to js v9 cert (#66009) Co-authored-by: Zaira <33151350+zairahira@users.noreply.github.com> Co-authored-by: majestic-owl448 <26656284+majestic-owl448@users.noreply.github.com> Co-authored-by: Kiruthika R <146549751+kiruthikadev-r@users.noreply.github.com> --- client/i18n/locales/english/intro.json | 7 + .../699c2dd0e2e1f947791f33fc.md | 223 ++++++++++++++++++ .../blocks/review-data-structures-js.json | 11 + .../structure/superblocks/javascript-v9.json | 1 + 4 files changed, 242 insertions(+) create mode 100644 curriculum/challenges/english/blocks/review-data-structures-js/699c2dd0e2e1f947791f33fc.md create mode 100644 curriculum/structure/blocks/review-data-structures-js.json diff --git a/client/i18n/locales/english/intro.json b/client/i18n/locales/english/intro.json index 30287d949e9..eb60cdf5c16 100644 --- a/client/i18n/locales/english/intro.json +++ b/client/i18n/locales/english/intro.json @@ -3316,6 +3316,13 @@ "title": "Recursion Quiz", "intro": ["Test your knowledge of Recursion with this quiz."] }, + "review-data-structures-js": { + "title": "Data Structures Review", + "intro": [ + "Before you're quizzed on data structures, you should review what you've learned about them.", + "Open up this page to review concepts like the different data structures, algorithms, time and space complexity, and big O notation." + ] + }, "quiz-data-structures-js": { "title": "Data Structures Quiz", "intro": [ diff --git a/curriculum/challenges/english/blocks/review-data-structures-js/699c2dd0e2e1f947791f33fc.md b/curriculum/challenges/english/blocks/review-data-structures-js/699c2dd0e2e1f947791f33fc.md new file mode 100644 index 00000000000..736e6c48379 --- /dev/null +++ b/curriculum/challenges/english/blocks/review-data-structures-js/699c2dd0e2e1f947791f33fc.md @@ -0,0 +1,223 @@ +--- +id: 699c2dd0e2e1f947791f33fc +title: Data Structures Review +challengeType: 31 +dashedName: review-data-structures-js +--- + +# --interactive-- + +## Algorithms and Big O Notation + +- **Algorithms**: A set of unambiguous instructions for solving a problem or carrying out a task. Algorithms must finish in a finite number of steps and each step must be precise and unambiguous. + +- **Big O Notation**: Describes the worst-case performance, or growth rate, of an algorithm as the input size increases. It focuses on how resource usage grows with input size, ignoring constant factors and lower-order terms. + +### Common Time Complexities + +- **O(1) - Constant Time**: Algorithm takes the same amount of time regardless of input size. + +:::interactive_editor + +```js +function checkEvenOrOdd(number) { + if (number % 2 === 0) { + return "Even"; + } else { + return "Odd"; + } +} + +console.log(checkEvenOrOdd(4)) // "Even" +console.log(checkEvenOrOdd(5)) // "Odd" +``` + +::: + +- **O(log n) - Logarithmic Time**: Time increases slowly as input grows. Common in algorithms that repeatedly reduce problem size by a fraction (like Binary Search). + +- **O(n) - Linear Time**: Running time increases proportionally to input size. + +```js +for (const grade of grades) { // grades is an array + console.log(grade); +} +``` + +- **O(n log n) - Log-Linear Time**: Common time complexity of efficient sorting algorithms like Merge Sort and Quick Sort. + +- **O(n²) - Quadratic Time**: Running time increases quadratically. Often seen in nested loops. + +:::interactive_editor + +```js +const n = 3; + +for (let i = 0; i < n; i++) { + for (let j = 0; j < n; j++) { + console.log("Hello, World!"); + } +} +``` + +::: + +### Space Complexity + +- **O(1) - Constant Space**: Algorithm uses same amount of memory regardless of input size. +- **O(n) - Linear Space**: Memory usage grows proportionally with input size. +- **O(n²) - Quadratic Space**: Memory usage grows quadratically with input size. + +## Problem-Solving Techniques + +- **Understanding the Problem**: Read the problem statement multiple times. Identify the input, expected output, and how to transform input to output. + +- **Pseudocode**: High-level description of algorithm logic that is language-independent. Uses common written language mixed with programming constructs like `IF`, `ELSE`, `FOR`, `WHILE`. + +```md +GET original_string +SET reversed_string = "" +FOR EACH character IN original_string: + ADD character TO THE BEGINNING OF reversed_string +DISPLAY reversed_string +``` + +- **Edge Cases**: Specific, valid inputs that occur at the boundaries of what an algorithm should handle. Always consider and test edge cases. + +## Arrays + +- **Static Arrays**: Have a fixed size determined at initialization. Elements stored in adjacent memory locations. Size cannot be changed during program execution. + +- **Dynamic Arrays**: Can grow or shrink automatically during program execution. Handle resizing through automatic copying to larger arrays when needed. + +### Dynamic Arrays Implementation in JavaScript + +:::interactive_editor + +```js +let numbers = [3, 4, 5, 6]; +// Access elements +console.log(numbers[0]) // 3 + +// Update elements +numbers[2] = 16 +console.log([...numbers]); // [3, 4, 16, 6] + +// Add elements +numbers.push(7) +console.log([...numbers]); // [3, 4, 16, 6, 7] + +// Add at a specific index +numbers.splice(3, 0, 15); +console.log([...numbers]); // [3, 4, 16, 15, 6, 7] + +// Remove elements +numbers.splice(2, 1); // Remove at specific index +console.log([...numbers]); // [3, 4, 15, 6, 7] + +numbers.pop() // Remove last element +console.log([...numbers]); // [3, 4, 15, 6] +``` + +::: + +### Time Complexities for Dynamic Arrays + +- **Access**: O(1) +- **Insert at end**: O(1) average, O(n) when resizing needed +- **Insert in middle**: O(n) +- **Delete**: O(n) for middle, O(1) for end + +## Stacks + +- **Stacks**: Last-In, First-Out (LIFO) data structure. Elements added and removed from the top only. + +- **Push Operation**: Adding an element to the top of the stack. Time complexity: O(1). + +- **Pop Operation**: Removing an element from the top of the stack. Time complexity: O(1). + +:::interactive_editor + +```js +// Using JavaScript array as a stack + +let stack = []; + +// Push operations +stack.push(1); +stack.push(2); +stack.push(3); +console.log([...stack]); // [1, 2, 3] + +// Pop operations +let topElement = stack.pop(); +console.log(topElement); // 3 +console.log([...stack]); // [1, 2] +``` + +::: + +## Queues + +- **Queues**: First-In, First-Out (FIFO) data structure. Elements added to the back and removed from the front. + +- **Enqueue Operation**: Adding an element to the back of the queue. Time complexity: O(1). + +- **Dequeue Operation**: Removing an element from the front of the queue. Time complexity: O(1). + +:::interactive_editor + +```js +// Using JavaScript array as a queue +let queue = []; + +// Enqueue operations +queue.push(1); +queue.push(2); +queue.push(3); +console.log([...queue]); // [1, 2, 3] + +// Dequeue operations +let firstElement = queue.shift(); +console.log(firstElement); // 1 +console.log([...queue]); // [2, 3] +``` + +::: + +## Linked Lists + +- **Linked Lists**: Linear data structure where each node contains data and a reference to the next node. Nodes are connected like a chain. + +### Singly Linked Lists + +- **Structure**: Each node has data and one reference to the next node. +- **Traversal**: Can only move forward from head to tail. +- **Head Node**: First node in the list, usually the only directly accessible node. +- **Tail Node**: Last node in the list, points to `null`. + +### Operations and Time Complexities + +- **Insert at beginning**: O(1) +- **Insert at end**: O(n) - must traverse to end +- **Insert in middle**: O(n) - must traverse to position +- **Delete from beginning**: O(1) +- **Delete from end**: O(n) - must traverse to find previous node +- **Delete from middle**: O(n) - must traverse to find node + +### Doubly Linked Lists + +- **Structure**: Each node has data and two references: next node and previous node. +- **Traversal**: Can move in both directions. +- **Memory**: Requires more memory than singly linked lists due to extra reference. + +## When to Use Each Data Structure + +- **Arrays (dynamic arrays)**: When you need ordered, indexed access and don't know size in advance +- **Stacks**: For LIFO operations (undo functionality, expression evaluation, backtracking) +- **Queues**: For FIFO operations (task scheduling, breadth-first search) +- **Linked Lists**: When frequent insertion/deletion at beginning, unknown size, no random access needed + +# --assignment-- + +Review the Data Structures topics and concepts. diff --git a/curriculum/structure/blocks/review-data-structures-js.json b/curriculum/structure/blocks/review-data-structures-js.json new file mode 100644 index 00000000000..c17c39c0671 --- /dev/null +++ b/curriculum/structure/blocks/review-data-structures-js.json @@ -0,0 +1,11 @@ +{ + "name": "Data Structures Review", + "isUpcomingChange": true, + "dashedName": "review-data-structures-js", + "helpCategory": "JavaScript", + "blockLayout": "link", + "challengeOrder": [ + { "id": "699c2dd0e2e1f947791f33fc", "title": "Data Structures Review" } + ], + "blockLabel": "review" +} diff --git a/curriculum/structure/superblocks/javascript-v9.json b/curriculum/structure/superblocks/javascript-v9.json index 9e136a00563..4bb84ec4453 100644 --- a/curriculum/structure/superblocks/javascript-v9.json +++ b/curriculum/structure/superblocks/javascript-v9.json @@ -301,6 +301,7 @@ "blocks": [ "lecture-working-with-common-data-structures-js", "lab-implement-a-queue", + "review-data-structures-js", "quiz-data-structures-js" ] },